home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 January: Mac OS SDK / Dev.CD Jan 96 SDK / Dev.CD Jan 96 SDK1.toast / Development Kits (Disc 1) / AppleScript / Development Tools / Sample Code / 7Edit / Pascal Sources / SVAppleEvents.p < prev    next >
Encoding:
Text File  |  1994-02-25  |  166.0 KB  |  5,995 lines  |  [TEXT/MPS ]
  1. {[d-,h-,k+,o=100,q+,r+,rec+,t=2,u+,:+,j=15/20/25/30/35/40/45/50/57/1$]} {Pasmat opts!}
  2.  
  3. UNIT SVAppleEvents;
  4.  
  5. (*
  6.     SVAppleEvents.p 
  7.   
  8.     Version 3.0d8
  9.     
  10.     Copyright © SRL Data 1992, 1993
  11.     
  12.     All rights reserved
  13.     
  14.     Produced by : SRL Data
  15.     Originally Developed for UK.DTS
  16.  
  17. *)
  18.  
  19. { New for 3.0d1 :
  20.         Recommenting of many functions to improve clarity.
  21.         Implementation of nearly all menu commands via Apple Events.
  22.         Page Setup on each window (with visible page breaks)
  23.         Show Borders on each window with bug fixes in display.
  24.         
  25.     New for 3.0d2 :
  26.         19-Feb-92 : NH : Implement printing
  27.                      Fix drawing on scrollbar on show page breaks
  28.                                          Make IssueAEOpenDoc a function (for printing)
  29.                                          Make Paste Styled
  30.         
  31.         21-Feb-92 : NH : Use new (in SVEditions.p) calls for updating section info.
  32.         
  33.         27-Feb-92 : NH : SendTextMessage zapped and other routines used solely by it.
  34.         
  35.         
  36.          5-Mar-92 : NH : Added HandleCreatePub, IssueCreatePub
  37.         18-Mar-92 : NH : Zap PoseMessageDialog & mod AdornDefault
  38.         27-Mar-92 : NH : Call AssocAllSections when saved
  39.         
  40.         Start of updating to constants in Winter AERegistry.
  41.         
  42.          3-Jun-92 : NH : Check for AEInteraction allowed before printing.
  43.          
  44.   New for 3.0d3 :
  45.     
  46.         16-Jun-92 : NH : Continue updating to match latest registry.
  47.                          typeText gone - now typeChar
  48.                                          classes of kAECut etc. changed (see registry)
  49.                                          Added pIsModified code.
  50.         17-Jun-92 : NH : Modify HandleSetData - Use AEResolve to yield tokenDescriptor, then
  51.                          extract appropriate token data.
  52.         18-Jun-92 : NH : Tidy up
  53.                                          Fix AEDescs being left after send of events
  54.                          Ensure SendAESetObjProp zaps all supplied params - now VAR params
  55.                                          Zap AEDescs left behind in HandleGetData.
  56.         26-Jun-92 : NH : Zap AddNamedStyleItem, AddNamedStyleItem, BuildStyleDescList
  57.                          Add code for typeTextStyles as per registry.
  58.                                          DoOpenDocument fixed to cope with no files in list etc.
  59.                                          Fixed buggy cast of windowToken to DPtr in DoCloseWindow
  60.                                          HandleShowSelection modified to take textTokens and WindowTokens
  61.                                          Fix sizeof in MakeSelfAddress.
  62.         25-Jun-92 : NH : StyleToName zapped
  63.         
  64.     Changes for 3.0d4 :
  65.     
  66.        3-Jul-92 : NH : Fix SetWindowProperty typeMyText
  67.          7-Jul-92 : NH : Add missing window props - pIsFloating, pHasCloseBox, pIsZoomable
  68.         13-Jul-92 : NH : Complete the menu classes.
  69.                          Allow -ve absolute positions - i.e. last line of ...
  70.                                          Change Line access to allow relative offsets
  71.       14-Jul-92 : NH : Change region massages for window positions (thanks huggy!)
  72.         15-Jul-92 : NH : Modified HandleGetData/SetData to allow styledText and typeChar
  73.                          Recording of keyStrokes
  74.         17-Jul-92 : NH : Enter key -> compile text - filtered out too
  75.                          Fix setting of styles so that styles not in on/off styles untouched
  76.          5-Aug-92 : NH : Add pUserSelection
  77.                                           Zap cSelection
  78.                                          Added MakeSelectedTextObject for Gustav
  79.                                          Styles made to match behaviour in Inside Mac VI
  80.                                          Fixed setting of styles to match registry
  81.                                          Fixed saving to work after name change of window
  82.                                          Mark document as dirty after SetData
  83.                                          Feed back all filing errors
  84.                                          Moved some data from descriptor procedures to SVEditAEUtils.c
  85.                                          
  86.     Changes for 3.0d5: 
  87.     
  88.         10-Aug-92 : NH : Fixed Quit save no - AEInteractWithUser called now
  89.                                          Added IssueQuitCommand.
  90.                                          Install cLine from typeMyText accessor
  91.     Changes for 3.0d6: 
  92.     
  93.         10-Sep-92 : JL : Fixed gTypingBuffer- this was not initialised in the Pascal
  94.                          version, although it was in C.
  95.                                          Added check for gRecordingImplemented when sending text just for
  96.                                          recording.
  97.     Changes for 3.0d7: 
  98.     
  99.         16-Nov-92 : JL : Changed pUserSelection to pSelection
  100. }
  101.  
  102. {
  103. This file includes :
  104.  
  105.     a) the code for the AppleEvent initialisation 
  106.     b) the routines for all the Edition Manager events
  107.     c) the Apple® Event Object Support
  108. }
  109.  
  110. INTERFACE
  111.  
  112. USES
  113.         MemTypes, 
  114.         QuickDraw,
  115.         Packages,
  116.         GestaltEqu,
  117.         
  118.         AppleEvents,
  119.         AEObjects,
  120.         AEPackObject,
  121.         Editions, 
  122.         Printing,
  123.         Menus,
  124.         
  125.         SVEditGlobals,
  126.         SVEditUtils,
  127.         SVEditFile, 
  128.         SVEditWindow, 
  129.         SVEditions;
  130.  
  131. PROCEDURE InitAppleEvents;
  132. PROCEDURE DoAppleEvent(theEvent : EventRecord);
  133.  
  134. (*
  135.     Text Commands
  136. *)
  137. PROCEDURE IssueCutCommand(theDocument:DPtr);
  138. PROCEDURE IssueCopyCommand(theDocument:DPtr);
  139. PROCEDURE IssuePasteCommand(theDocument:DPtr);
  140. PROCEDURE IssueClearCommand(theDocument:DPtr);
  141. PROCEDURE IssueFontCommand(theDocument:DPtr;theItem:INTEGER);
  142. PROCEDURE IssueSizeCommand(theDocument:DPtr;theItem:INTEGER);
  143. PROCEDURE IssueStyleCommand(theDocument:DPtr;theItem:INTEGER);
  144.  
  145. (*
  146.     Window Commands
  147. *)
  148.  
  149. PROCEDURE IssueZoomCommand(whichWindow:WindowPtr; whichPart:INTEGER);
  150. PROCEDURE IssueCloseCommand(whichWindow:WindowPtr);
  151. PROCEDURE IssueSizeWindow(whichWindow:WindowPtr; newHSize:INTEGER; newVSize:INTEGER);
  152. PROCEDURE IssueMoveWindow(whichWindow:windowPtr; sizeRect:Rect);
  153. PROCEDURE IssuePageSetupWindow(whichWindow:windowPtr; thePageSetup:TPrint);
  154. PROCEDURE IssueShowBorders(whichWindow:windowPtr; showBorders:BOOLEAN);
  155. PROCEDURE IssuePrintWindow(whichWindow:windowPtr);
  156.  
  157. (*
  158.     Document Commands
  159. *)
  160.  
  161. FUNCTION  IssueAEOpenDoc(myFSSpec: FSSpec):OSErr;
  162. PROCEDURE IssueAENewWindow;
  163. FUNCTION  IssueSaveCommand(theWindow    : WindowPtr;
  164.                                                 where            : FSSpecPtr):OSErr;
  165.                                                 
  166. FUNCTION  IssueRevertCommand(theWindow    : WindowPtr):OSErr;
  167. FUNCTION  IssueQuitCommand:OSErr;
  168.  
  169. PROCEDURE IssueCreatePublisher(whichDoc:DPtr);
  170.  
  171. (*
  172.     Recording of Keystrokes
  173. *)
  174.  
  175. PROCEDURE AddKeyToTypingBuffer(theDocument : DPtr; theKey :char);
  176.  
  177. PROCEDURE FlushAndRecordTypingBuffer;
  178.  
  179. IMPLEMENTATION
  180.  
  181. USES
  182.     Fonts,
  183.     Scrap,
  184.     SysEqu,
  185.     AERegistry,
  186.     SVEditAEUtils;
  187.     
  188. CONST     
  189.         
  190.         { these should come from the registry }
  191.         
  192.         kAEStartedRecording     = 'rec1';
  193.         kAEStoppedRecording     = 'rec0';
  194.         
  195.                 
  196.         pText                     =     'TEXT';
  197.         cSpot                     =     'cspt';
  198.                                                 
  199.         (*
  200.             Text Properties
  201.         *)
  202.         
  203.         pStringWidth                        =   'pwid';
  204.         
  205.         (*
  206.             Window Properties - See the Registry for Details
  207.         *)
  208.  
  209.         pPosition                                =    'ppos';
  210.  
  211.         pPageSetup                            = 'PSET'; (* One of ours - Not in registry *)
  212.         pShowBorders                        = 'PBOR'; (* Another of ours *)
  213.                 
  214.         typeTPrint                            = 'TPNT'; (* A raw TPrint record - also one of ours *)
  215.                                 
  216.     (*
  217.             Error Codes
  218.         *)
  219.         
  220.         kAEGenericErr           = -1799;
  221.  
  222. TYPE typingBuffer = PACKED ARRAY[0..31999] OF CHAR;
  223.      typingBufPtr = ^typingBuffer;
  224.  
  225. VAR gBigBrother         : INTEGER; (* Count of Scripting Systems recording us *)
  226.     gTypingBuffer       : typingBufPtr;
  227.     gCharsInBuffer      : INTEGER;
  228.     gTypingTargetObject : AEDesc;
  229.         
  230. {-----------------------------------------------------------------------}
  231. {*----------                         APPLE EVENT HANDLING                     ---------------*}
  232. {-----------------------------------------------------------------------}
  233.  
  234. {$S Main}
  235.  
  236. {*-----------------------------------------------------------------------
  237.     Utility Routines for getting data from AEDesc's
  238.   -----------------------------------------------------------------------*}
  239.  
  240. FUNCTION GetTHPrintFromDescriptor(sourceDesc   : AEDesc;
  241.                                                                 VAR result   : THPrint):OSErr;
  242. VAR myErr           : OSErr;
  243.     ignoreErr   : OSErr;
  244.         ptSize          : Size;
  245.         resultDesc    : AEDesc;
  246.         
  247. BEGIN    
  248.     myErr := AECoerceDesc(sourceDesc,typeTPrint,resultDesc);
  249.     
  250.     result := NIL;
  251.     
  252.     IF (myErr=noErr) THEN
  253.         BEGIN
  254.             result := THPrint(NewHandle(SizeOf(TPrint)));
  255.             
  256.             PrOpen;
  257.             PrintDefault(result);
  258.             
  259.             HLock(Handle(result));
  260.  
  261.             GetRawDataFromDescriptor(resultDesc,
  262.                                                              @result^^,
  263.                                                              sizeof(TPrint),
  264.                                                              ptSize);
  265.                                                              
  266.             HUnLock(Handle(result));
  267.             
  268.             IF (ptSize<sizeof(TPrint)) OR
  269.                  (PrValidate(result)) THEN
  270.                 BEGIN
  271.                     myErr := errAECoercionFail;
  272.                     DisposHandle(Handle(result));
  273.                     result := NIL;
  274.                 END;
  275.             
  276.             PrClose;
  277.         END;
  278.     
  279.     IF (resultDesc.dataHandle<>NIL) THEN
  280.         ignoreErr := AEDisposeDesc(resultDesc);
  281.         
  282.     GetTHPrintFromDescriptor := myErr;
  283. END; (*GetTHPrintFromDescriptor*)
  284.  
  285.  
  286. {*****************************************************************************}
  287. {
  288.     Object Accessors - Utility Routines
  289. }
  290.  
  291. {$S ObjectAccessors}
  292.  
  293. FUNCTION WindowNameToWindowPtr(nameStr: StringPtr): WindowPtr;
  294. { 
  295.     Returns the WindowPtr of the window with title nameStr
  296.     or NIL if there is no matching window.
  297. }
  298. VAR theWindow :    WindowPtr;
  299.       windTitle :    Str255;
  300.         
  301. BEGIN
  302.   WindowNameToWindowPtr := NIL;
  303.   theWindow := WindowPtr(Handle(WindowList)^);
  304.   { 
  305.         iterate through windows - we use WindowList 'cos we could
  306.         have made the window invisible and then we lose it - so we
  307.         can't set it back to visible!!
  308.     }
  309.   WHILE theWindow <> NIL DO
  310.     BEGIN
  311.             GetWTitle(theWindow,windTitle);
  312.             IF EqualString(windTitle,nameStr^,FALSE,TRUE) THEN    { ignore case, don't ignore diacriticals }
  313.                 BEGIN
  314.                     WindowNameToWindowPtr := theWindow;
  315.                     EXIT(WindowNameToWindowPtr);
  316.                 END;
  317.       theWindow := WindowPtr(WindowPeek(theWindow)^.nextWindow);
  318.     END;
  319. END;    { WindowNameToWindowPtr }
  320.  
  321. FUNCTION GetWindowPtrOfNthWindow(index: INTEGER): WindowPtr;
  322. { returns a ptr to the window with the given index
  323.   (front window is 1, behind that is 2, etc.).  If
  324.   there's no window with that index (inc. no windows
  325.   at all), returns NIL.
  326. }
  327. VAR theWindow    :    WindowPtr;
  328.         
  329. BEGIN
  330.   GetWindowPtrOfNthWindow := NIL;
  331.   theWindow := WindowPtr(Handle(WindowList)^);
  332.  
  333.   { iterate through windows }
  334.     
  335.   WHILE (theWindow <> NIL) DO
  336.       BEGIN
  337.         index := index-1;
  338.             IF (index <= 0) THEN
  339.                 BEGIN
  340.                     GetWindowPtrOfNthWindow := theWindow;
  341.                     EXIT(GetWindowPtrOfNthWindow);
  342.                 END;
  343.                 
  344.       theWindow := WindowPtr(WindowPeek(theWindow)^.nextWindow);
  345.         END;
  346. END;    { GetWindowPtrOfNthWindow }
  347.  
  348. FUNCTION CountWindows:INTEGER;
  349.     VAR theWindow : WindowPtr;
  350.         index     : INTEGER;
  351.             
  352.     BEGIN
  353.         index := 0;
  354.         theWindow := WindowPtr(Handle(WindowList)^);
  355.     
  356.         { iterate through windows }
  357.         
  358.         WHILE (theWindow <> NIL) DO
  359.             BEGIN
  360.                 index := index+1;                    
  361.                 theWindow := WindowPtr(WindowPeek(theWindow)^.nextWindow);
  362.             END;
  363.         
  364.         CountWindows := index;
  365.         
  366.     END; (*CountWindows*)
  367.     
  368. FUNCTION ItemForNamedFont(theName:Str255):INTEGER;
  369.     VAR itemName : Str255;
  370.             limit    : INTEGER;
  371.     
  372.     BEGIN
  373.         ItemForNamedFont := 0;
  374.         limit := CountMItems(myMenus[fontM]);
  375.         WHILE (limit>0) DO
  376.             BEGIN
  377.                 GetItem(myMenus[fontM],limit,itemName);
  378.                 IF IUEqualString(theName, itemName)=0 THEN
  379.                     BEGIN
  380.                         ItemForNamedFont := limit;
  381.                         limit:=0;
  382.                     END
  383.                 ELSE
  384.                     limit := limit-1;
  385.             END;
  386.     END; (*ItemForNamedFont*)
  387.  
  388. {*-----------------------------------------------------------------------
  389.         Name:             DoOpenApp
  390.         Purpose:        Called on startup, creates a new document.
  391.     -----------------------------------------------------------------------*}
  392.  
  393. {$S Main}
  394. FUNCTION DoOpenApp( message, reply: AppleEvent; refcon: LONGINT ): OSErr;             
  395. VAR ourDoc : DPtr;
  396.  
  397. BEGIN
  398.     {just create a new document}
  399.     ourDoc := NewDocument(false);
  400.     
  401.     IF ourDoc<>NIL THEN
  402.         BEGIN
  403.             ShowWindow(ourDoc^.theWindow);
  404.             DoOpenApp := noErr
  405.         END
  406.     ELSE
  407.         DoOpenApp := -108;
  408. END;
  409.  
  410. {*-----------------------------------------------------------------------
  411.         Name:             DoOpenDocument
  412.         Purpose:        Open all the documents passed in the Open AppleEvent.
  413. -----------------------------------------------------------------------*}
  414.  
  415. {$S Main}
  416. FUNCTION DoOpenDocument( message, reply: AppleEvent; refcon: LONGINT ): OSErr;            
  417. VAR
  418.         index,
  419.         itemsInList : LONGINT;
  420.         keywd             : AEKeyWord;
  421.         err                 : OSErr;
  422.         ignoreErr     : OSErr;
  423.         docList         : AEDescList;
  424.         actSize         : LONGINT;
  425.         typeCode        : DescType;
  426.         theFSSpec     : FSSpec;
  427.         
  428.  
  429. BEGIN
  430.     {open the specified documents}
  431.   
  432.     docList.dataHandle := NIL;
  433.     
  434.     err := AEGetParamDesc(message, keyDirectObject, typeAEList, docList) ;
  435.     IF (err=noErr) THEN
  436.         err := AECountItems( docList, itemsInList)
  437.     ELSE
  438.         itemsInList := 0;
  439.         
  440.     FOR index := 1 TO itemsInList DO
  441.         IF (err=noErr) THEN
  442.             BEGIN
  443.                 err := AEGetNthPtr( docList,
  444.                                     index,
  445.                                                         typeFSS, 
  446.                                                         keywd, 
  447.                                                         typeCode,
  448.                                               @theFSSpec,
  449.                                                         sizeof(theFSSpec),
  450.                                                         actSize);
  451.                 IF (err=noErr) THEN
  452.                  err := OpenOld(theFSSpec);
  453.             END;
  454.             
  455.     IF (docList.dataHandle<>NIL) THEN
  456.         ignoreErr := AEDisposeDesc(docList);
  457.         
  458.     DoOpenDocument := err;
  459. END;
  460.  
  461. {*-----------------------------------------------------------------------
  462.         Name:             MyQuit
  463.         Purpose:        Quit event received- exit the program.
  464.     -----------------------------------------------------------------------*}
  465.  
  466. {$S Main}
  467. FUNCTION MyQuit(message : AppleEvent;reply : AppleEvent;refcon:LONGINT): OSErr;
  468.     VAR
  469.         saveOpt      : DescType;
  470.         tempErr      : OSErr;
  471.         myErr        : OSErr;
  472.         returnedType : DescType;
  473.         actSize      : LONGINT;
  474.         
  475.     BEGIN
  476.         saveOpt := kAEAsk; (* the default *)
  477.         tempErr := AEGetParamPtr(message,
  478.                                                          keyAESaveOptions,
  479.                                                          typeEnumerated,
  480.                                                          returnedType,
  481.                                                          Ptr(@saveOpt),
  482.                                                          sizeof(saveOpt),
  483.                                                          actSize);
  484.         
  485.         IF (saveOpt <> kAENo) THEN
  486.             myErr := AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  487.  
  488.       IF (myErr = noErr) THEN
  489.             DoQuit(saveOpt);
  490.         
  491.         myQuit := myErr;
  492.     END;
  493.  
  494. {*-----------------------------------------------------------------------
  495.         Name:             DoAppleEvent
  496.         Purpose:        Process and despatch the AppleEvent
  497.     -----------------------------------------------------------------------*}
  498.  
  499. {$S Main}
  500. PROCEDURE DoAppleEvent(theEvent : EventRecord);
  501.  
  502. VAR err: OsErr;
  503.  
  504. BEGIN
  505.     {should check for your own event message types here - if you have any}
  506.     
  507.     err := AEProcessAppleEvent(theEvent);
  508. END;
  509.  
  510. {*-----------------------------------------------------------------------
  511.         Name:             MakeSelfAddress
  512.         Purpose:        Builds an AEAddressDesc for the current process
  513.     -----------------------------------------------------------------------*}
  514.     
  515. FUNCTION MakeSelfAddress(VAR selfAddress : AEAddressDesc) :  OSErr;
  516.  
  517. VAR
  518.     procSerNum : ProcessSerialNumber;
  519.     
  520. BEGIN
  521.     procSerNum.highLongOfPSN := 0;
  522.     procSerNum.lowLongOfPSN  := kCurrentProcess;
  523.     
  524.     MakeSelfAddress := AECreateDesc(typeProcessSerialNumber,
  525.                                                                     Ptr(@procSerNum),
  526.                                                                     sizeof(procSerNum),
  527.                                                                     selfAddress);
  528.     
  529. END; (* MakeSelfAddress *)
  530.  
  531. {*--------------------------------------------------------------------
  532.     Name : SendAESetObjProp
  533.     Function : Creates a property object from an object,
  534.                          a property type and its data and sends it to
  535.                          the requested address, and cleans up zapping params too
  536.     --------------------------------------------------------------------*}
  537.  
  538. FUNCTION SendAESetObjProp(VAR theObj    : AEDesc; 
  539.                                                     theProp        : DescType;
  540.                                                     VAR theData    : AEDesc;
  541.                                                     VAR toWhom  : AEAddressDesc):OSErr;
  542.                                                      
  543. VAR propObjSpec        :    AEDesc;
  544.         myAppleEvent    :    AppleEvent;
  545.         defReply            :    AppleEvent;
  546.         myErr         : OSErr;
  547.         ignoreErr     : OSErr;
  548.         theProperty   : AEDesc;
  549.         
  550. BEGIN
  551.   { create an object spec that represents the property of the given object }
  552.   
  553.     myErr := AECreateDesc(typeType,
  554.                                                 @theProp,
  555.                                                 sizeof(theProp),
  556.                                                 theProperty);
  557.     
  558.     IF (myErr=noErr) THEN
  559.         myErr:= CreateObjSpecifier(cProperty,
  560.                                                              theObj,
  561.                                                              formPropertyID,
  562.                                                              theProperty,
  563.                                                              TRUE,
  564.                                                              propObjSpec);    
  565.       
  566.   { create event }
  567.     
  568.     IF (myErr=noErr) THEN
  569.         myErr := AECreateAppleEvent(kAECoreSuite,
  570.                                                                 kAESetData,
  571.                                                                 toWhom,
  572.                                                                 0,
  573.                                                                 0,
  574.                                                                 myAppleEvent);
  575.       
  576.   { add prop obj spec to the event }
  577.     
  578.     IF (myErr=noErr) THEN
  579.         myErr := AEPutParamDesc(myAppleEvent,keyDirectObject,propObjSpec);
  580.   
  581.   { add prop data to the event }
  582.     
  583.     IF (myErr=noErr) THEN
  584.         myErr := AEPutParamDesc(myAppleEvent,keyAEData,theData);
  585.   
  586.   { send event }
  587.     
  588.     IF (myErr=noErr) THEN    
  589.         myErr := AESend(myAppleEvent,
  590.                                         defReply,
  591.                                         kAENoReply+kAEAlwaysInteract,
  592.                                         kAENormalPriority,
  593.                                         kAEDefaultTimeOut,
  594.                                         NIL,
  595.                                         NIL);
  596.   
  597.   ignoreErr := AEDisposeDesc(myAppleEvent);
  598.   
  599.   ignoreErr := AEDisposeDesc(propObjSpec);
  600.     
  601.     ignoreErr := AEDisposeDesc(theData);
  602.     
  603.     ignoreErr := AEDisposeDesc(toWhom);
  604.     
  605.     SendAESetObjProp := myErr;
  606.     
  607. END;    { SendAESetObjProp }
  608.  
  609. {----------------------------------------------------------------------------------------------}
  610. {
  611.     Private AEObject definitions
  612. }
  613. {$S AECommandHandlers}
  614.  
  615. CONST
  616.     typeMyAppl        = 'BAPP'; { sig of my private token type for the app     - appToken   }
  617.   typeMyWndw              =    'BWIN';    { sig of my private token type for windows     - windowToken   }
  618.     typeMyText            =    'BTXT';    { sig of my private token type for text        - textToken     }
  619.     typeMyTextProp    =    'BPRP';    { sig of my private token type for text properties    - textPropToken }
  620.     typeMyWindowProp  =    'WPRP';    { sig of my private token type for window properties  - windowPropToken }
  621.     typeMyApplProp      =    'APRP';    { sig of my private token type for appl properties    - applPropToken }
  622.     typeMyMenu        = 'MTKN'; { sig of my private token type for menus       - menuToken  }
  623.     typeMyMenuItem    = 'ITKN'; { sig of my private token type for menus       - menuItemToken  }
  624.     typeMyMenuProp    = 'MPRP'; { sig of my private token type for menu properties - menuPropToken  }
  625.     typeMyItemProp    = 'IPRP'; { sig of my private token type for menu item properties  - menuItemPropToken  }
  626.  
  627. TYPE 
  628.     (* These are entirely private to our app - used only when resolving the object specifier *)
  629.     
  630.     appToken    = ProcessSerialNumber;
  631.     
  632.     applPropToken = RECORD
  633.                                             tokenApplToken    : appToken;
  634.                                             tokenApplProperty : DescType;
  635.                                         END;
  636.                                         
  637.     windowToken = WindowPtr;
  638.     
  639.     windowPropToken = RECORD
  640.                                             tokenWindowToken : WindowToken;
  641.                                             tokenProperty    : DescType;
  642.                                         END;
  643.     
  644.     textToken   = RECORD
  645.                                     tokenWindow : WindowPtr;
  646.                                     tokenOffset : INTEGER;
  647.                                     tokenLength : INTEGER;
  648.                                 END;
  649.                                 
  650.     textPropToken = RECORD
  651.                                         propertyTextToken : textToken;
  652.                                         propertyProperty    : DescType;
  653.                                     END;
  654.                                     
  655. (* Tokens related to menus *)
  656.  
  657. MenuToken = RECORD
  658.                             theTokenMenu : MenuHandle;
  659.                             theTokenID   : INTEGER;
  660.                         END;
  661.  
  662. MenuItemToken = RECORD
  663.                                     theMenuToken : MenuToken;
  664.                                     theTokenItem : INTEGER;
  665.                                 END;
  666.  
  667. MenuPropToken = RECORD
  668.                                     theMenuToken : MenuToken;
  669.                                     theMenuProp  : DescType;
  670.                                 END;
  671.  
  672. MenuItemPropToken = RECORD
  673.                                             theItemToken : MenuItemToken;
  674.                                             theItemProp  : DescType;
  675.                                         END;
  676.  
  677. FUNCTION GotRequiredParams(theAppleEvent: AppleEvent):  OSErr;
  678.     VAR myErr            : OSErr;
  679.         returnedType: DescType;
  680.         actSize            : Size;
  681.         
  682.     BEGIN
  683.         { look for the keyMissedKeywordAttr, just to see if it's there }
  684.         
  685.         myErr := AEGetAttributePtr(    theAppleEvent,
  686.                                                                 keyMissedKeywordAttr,
  687.                                                                 typeWildCard,
  688.                                                                 returnedType,
  689.                                                                 NIL,
  690.                                                                 0,
  691.                                                                 actSize);
  692.         
  693.         IF myErr = errAEDescNotFound THEN 
  694.             GotRequiredParams := noErr            { attribute not there means we got all req params }
  695.         ELSE 
  696.             IF myErr = noErr THEN 
  697.                 GotRequiredParams := errAEParamMissed        { attribute there means missed at least one }
  698.             ELSE 
  699.                 GotRequiredParams := myErr;        { some unexpected arror in looking for the attribute }
  700.     END;    (* GotReqiredParams *)
  701.  
  702. {*--------------------------------------------------------------------
  703.     Name : SetSelectionOfAppleEventDirectObject
  704.     Function : Resolves the Direct Object into a text token and
  705.                          sets the selection of the specified document to that
  706.                          specified in the direct object.
  707.                          Returns the doc and TEHandle chosen.
  708.     --------------------------------------------------------------------*}
  709.  
  710. FUNCTION SetSelectionOfAppleEventDirectObject(theAppleEvent        : AppleEvent;
  711.                                                                                              VAR theDocument : DPtr;
  712.                                                                                             VAR theHTE            : TEHandle):OsErr;
  713.     VAR myErr              : OSErr;
  714.             returnedType : DescType;
  715.             actSize      : longInt;
  716.             myTextToken  : TextToken;
  717.             paramErr     : OSErr;
  718.             
  719.     BEGIN
  720.         SetSelectionOfAppleEventDirectObject := noErr;
  721.         
  722.         paramErr := AEGetParamPtr(theAppleEvent,
  723.                                                             keyDirectObject,
  724.                                                             typeMyText,
  725.                                                             returnedType,
  726.                                                       @myTextToken,
  727.                                                             SizeOf(myTextToken),
  728.                                                             actSize);
  729.               
  730.         myErr := GotRequiredParams(theAppleEvent);
  731.         
  732.         { now let's work on the direct object, if any }
  733.         
  734.         IF (paramErr = errAEDescNotFound) THEN
  735.             BEGIN
  736.                 { no direct object; check we have a window }
  737.                 IF (FrontWindow = NIL) THEN
  738.                     BEGIN
  739.                         SetSelectionOfAppleEventDirectObject := -1700;
  740.                         Exit(SetSelectionOfAppleEventDirectObject);
  741.                     END;
  742.                 theDocument := DPtrFromWindowPtr(FrontWindow);
  743.                 theHTE      := theDocument^.theText;
  744.             END;
  745.         
  746.         IF (paramErr = noErr) THEN
  747.             BEGIN
  748.                 { got a text token }
  749.                 
  750.                 theDocument := DPtrFromWindowPtr(myTextToken.tokenWindow);
  751.                 theHTE      := theDocument^.theText;
  752.                 
  753.                 TESetSelect(myTextToken.tokenOffset-1,
  754.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  755.                                         theHTE);
  756.                 
  757.             END;
  758.             
  759.         IF (paramErr<>noErr) AND
  760.            (paramErr<>errAEDescNotFound) THEN
  761.              BEGIN
  762.                  theDocument := DPtrFromWindowPtr(FrontWindow);
  763.                  theHTE      := theDocument^.theText;
  764.              END;
  765.  
  766.         SetSelectionOfAppleEventDirectObject := myErr;
  767.              
  768.     END; (* SetSelectionOfAppleEventDirectObject *)
  769.     
  770. {*--------------------------------------------------------------------
  771.     Name             : SetSelectionOfAppleEventDirectObject
  772.     Function     : Resolves the whatObject type of the AppleEvent into a text
  773.                              token and sets the selection to be that specified in the
  774.                              text token.
  775.                              Returns the doc and TEHandle chosen.
  776.     --------------------------------------------------------------------*}
  777.  
  778. FUNCTION SetSelectionOfAppleEventObject(whatObject             : OSType;
  779.                                                                                 theAppleEvent        : AppleEvent;
  780.                                                                                  VAR theDocument : DPtr;
  781.                                                                                 VAR theHTE            : TEHandle):OsErr;
  782.     VAR returnedType : DescType;
  783.             actSize      : longInt;
  784.             myTextToken  : TextToken;
  785.             paramErr     : OSErr;
  786.             
  787.     BEGIN        
  788.         paramErr := AEGetParamPtr(theAppleEvent,
  789.                                                             whatObject,
  790.                                                             typeMyText,
  791.                                                             returnedType,
  792.                                                       @myTextToken,
  793.                                                             SizeOf(myTextToken),
  794.                                                             actSize);
  795.                                       
  796.         IF (paramErr = noErr) THEN
  797.             BEGIN
  798.                 { got a text token }
  799.                 
  800.                 theDocument := DPtrFromWindowPtr(myTextToken.tokenWindow);
  801.                 theHTE      := theDocument^.theText;
  802.                 
  803.                 TESetSelect(myTextToken.tokenOffset-1,
  804.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  805.                                         theHTE);
  806.                 
  807.             END;
  808.                              
  809.         SetSelectionOfAppleEventObject := paramErr;
  810.                  
  811.     END; (* SetSelectionOfAppleEventObject *)
  812.  
  813. { -----------------------------------------------------------------------
  814.         Name:             DoCutEdit
  815.         Purpose:        Performs a cut text operation on the current text selection
  816.      -----------------------------------------------------------------------*}
  817.     
  818. FUNCTION DoCutEdit(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  819.     VAR myErr              : OSErr;
  820.             theHTE             : TEHandle;
  821.             theDocument  : DPtr;
  822.     
  823.     BEGIN
  824.         myErr := SetSelectionOfAppleEventDirectObject(theAppleEvent,theDocument,theHTE);
  825.         
  826.         IF (myErr=noErr) THEN
  827.             BEGIN
  828.               DoTECutSectionRecalc(theDocument);
  829.             
  830.                 myErr := ZeroScrap;
  831.                 TECut(theHTE);
  832.                 AdjustScrollbars(theDocument, FALSE);
  833.                 DrawPageExtras(theDocument);
  834.                 theDocument^.dirty := TRUE;                
  835.             END;
  836.             
  837.         DoCutEdit := myErr;
  838.     END; (* DoCutEdit *)
  839.     
  840. { -----------------------------------------------------------------------
  841.         Name:             DoCopyEdit
  842.         Purpose:        Performs a copy text operation on the text selection specified
  843.                                 by the appleEvent direct object (if any)
  844.      -----------------------------------------------------------------------*}
  845.     
  846. FUNCTION DoCopyEdit(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  847.     VAR myErr              : OSErr;
  848.             theHTE             : TEHandle;
  849.             theDocument  : DPtr;
  850.     BEGIN
  851.         (*
  852.                 Here we extract the information about what to copy from the
  853.                 directObject - if any
  854.         *)
  855.         
  856.         myErr := SetSelectionOfAppleEventDirectObject(theAppleEvent,theDocument,theHTE);
  857.         
  858.         IF myErr=noErr THEN
  859.             BEGIN
  860.                 myErr := ZeroScrap;
  861.                 TECopy(theHTE);     
  862.             END;
  863.             
  864.         IF (myErr=noErr) THEN
  865.             IF (SetSelectionOfAppleEventObject(keyAEContainer, 
  866.                                                                                 theAppleEvent,
  867.                                                                                 theDocument,
  868.                                                                                 theHTE) = noErr) THEN
  869.                 BEGIN
  870.                     DoTEPasteSectionRecalc(theDocument);
  871.                     
  872.                     TEStylPaste(theHTE);
  873.                     
  874.                     AdjustScrollBars(theDocument, FALSE);
  875.                     
  876.                     DrawPageExtras(theDocument);
  877.                     
  878.                     theDocument^.dirty := TRUE;
  879.                 END;
  880.             
  881.         DoCopyEdit := myErr;
  882.     END; (* DoCopyEdit *)
  883.     
  884. { -----------------------------------------------------------------------
  885.         Name:             DoPasteEdit
  886.         Purpose:        Performs a paste text operation on the text selection specified
  887.                                 by the appleEvent direct object (if any)
  888.      -----------------------------------------------------------------------*}
  889.     
  890. FUNCTION DoPasteEdit(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  891.     VAR myErr              : OSErr;
  892.             theHTE             : TEHandle;
  893.             theDocument  : DPtr;
  894.     BEGIN
  895.         myErr := SetSelectionOfAppleEventDirectObject(theAppleEvent,theDocument,theHTE);
  896.         
  897.         IF myErr=noErr THEN
  898.             BEGIN
  899.                 DoTEPasteSectionRecalc(theDocument);
  900.                 
  901.                 TEStylPaste(theHTE);     
  902.  
  903.                 AdjustScrollbars(theDocument, FALSE);
  904.                 
  905.                 DrawPageExtras(theDocument);
  906.  
  907.                 theDocument^.dirty := TRUE;
  908.             END;
  909.             
  910.         DoPasteEdit := myErr;
  911.     END; (* DoPasteEdit *)
  912.     
  913. { -----------------------------------------------------------------------
  914.         Name:             DoDeleteEdit
  915.         Purpose:        Performs a delete text operation on the selection specified
  916.                                 by the appleEvent direct object (if any)
  917.      -----------------------------------------------------------------------*}
  918.      
  919. FUNCTION DoDeleteEdit(theAppleEvent,reply : AppleEvent; refcon : longInt):OSErr;
  920.     VAR myErr              : OSErr;
  921.             theHTE             : TEHandle;
  922.             theDocument  : DPtr;
  923.             
  924.     BEGIN
  925.         myErr := SetSelectionOfAppleEventDirectObject(theAppleEvent,theDocument,theHTE);
  926.         
  927.         IF myErr=noErr THEN
  928.             BEGIN
  929.                 DoTEDeleteSectionRecalc(theDocument);
  930.                         
  931.                 TEDelete(theHTE);     
  932.                 
  933.                 theDocument^.dirty := TRUE;
  934.                 AdjustScrollbars(theDocument, FALSE);
  935.                 DrawPageExtras(theDocument);
  936.             END;
  937.                     
  938.         DoDeleteEdit := myErr;
  939.     END; (*DoDeleteEdit*)
  940.     
  941. { -----------------------------------------------------------------------
  942.         Name:             SetTheFontOfTheTokenText
  943.         Purpose:        Sets the font of the text specified by theTextToken to 
  944.                                 the font in name.
  945.      -----------------------------------------------------------------------*}
  946.      
  947. PROCEDURE SetTheFontOfTheTokenText(theTextToken : textToken; name:Str255);
  948.     VAR theDocument : DPtr;
  949.             theNumber   : INTEGER;
  950.             theItem     : INTEGER;
  951.             oldPort     : GrafPtr;
  952.             newStyle        : textStyle;
  953.     
  954.     BEGIN
  955.         GetPort(oldPort);
  956.         
  957.         theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  958.                 
  959.         GetFNum(name, theNumber);
  960.         
  961.         theItem := ItemForNamedFont(name); (* returns 0 if failed - i.e. SystemFont *)
  962.         
  963.         IF gFontMItem <> 0 THEN
  964.             CheckItem(myMenus[fontM], gFontMItem, FALSE);
  965.         
  966.         gFontMItem := theItem;
  967.         CheckItem(myMenus[fontM], gFontMItem, TRUE);
  968.         
  969.         theDocument^.theFont := theNumber;
  970.         
  971.         TESetSelect(theTextToken.tokenOffset-1,
  972.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  973.                                 theDocument^.theText);
  974.         
  975.         newStyle.tsFont := theNumber;
  976.         TESetStyle(doFont, newStyle, TRUE, theDocument^.theText); 
  977.         
  978.         AdjustScrollbars(theDocument, FALSE);
  979.         DrawPageExtras(theDocument);
  980.         theDocument^.dirty := TRUE;
  981.         
  982.         SetPort(oldPort);
  983.     END; (* SetTheFontOfTheTokenText *)
  984.     
  985. { -----------------------------------------------------------------------
  986.         Name:             SetTheSizeOfTheTokenText
  987.         Purpose:        Sets the size of the text specified by theTextToken to 
  988.                                 the size in theSize.
  989.      -----------------------------------------------------------------------*}
  990.      
  991. PROCEDURE SetTheSizeOfTheTokenText(theTextToken : textToken; theSize:INTEGER);
  992.     VAR theDocument : DPtr;
  993.             oldPort     : GrafPtr;
  994.             newStyle    : textStyle;
  995.     
  996.     BEGIN
  997.         GetPort(oldPort);
  998.         
  999.         theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  1000.                                 
  1001.         theDocument^.theSize := theSize;
  1002.         
  1003.         TESetSelect(theTextToken.tokenOffset-1,
  1004.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  1005.                                 theDocument^.theText);
  1006.         
  1007.         newStyle.tsSize := theSize;
  1008.         TESetStyle(doSize, newStyle, TRUE, theDocument^.theText); 
  1009.         
  1010.         AdjustScrollbars(theDocument, FALSE);
  1011.         DrawPageExtras(theDocument);
  1012.         theDocument^.dirty := TRUE;
  1013.         
  1014.         SetPort(oldPort);
  1015.     END; (* SetTheSizeOfTheTokenText *)
  1016.     
  1017. { -----------------------------------------------------------------------
  1018.         Name:             SetTheStyleOfTheTokenText
  1019.         Purpose:        Sets the style of the text specified by theTextToken to 
  1020.                                 the style in theStyle.
  1021.      -----------------------------------------------------------------------*}
  1022.      
  1023. PROCEDURE SetTheStyleOfTheTokenText(theTextToken : textToken; 
  1024.                                     onStyle      : Style;
  1025.                                                                         offStyle     : Style);
  1026.     VAR theDocument   : DPtr;
  1027.             oldPort       : GrafPtr;
  1028.             newStyle          : TextStyle;
  1029.           mode          : INTEGER;
  1030.           wasContinuous : Boolean;
  1031.         
  1032.     BEGIN
  1033.         GetPort(oldPort);
  1034.         
  1035.         theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  1036.                                 
  1037.         theDocument^.theStyle := onStyle;
  1038.         TESetSelect(theTextToken.tokenOffset-1,
  1039.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  1040.                                 theDocument^.theText);
  1041.                                 
  1042.         { Check to see if off styles are on for whole selection }
  1043.         mode := doFace;
  1044.         
  1045.         wasContinuous := TEContinuousStyle(mode, newStyle, theDocument^.theText);
  1046.         
  1047.         if ((newStyle.tsFace * offStyle) <> offStyle) THEN (*not off styles are on for all *)
  1048.             BEGIN
  1049.               { switch on across board so that toggle off will clear all }
  1050.             newStyle.tsFace  := offStyle - (newStyle.tsFace * offStyle);
  1051.                 TESetStyle(doFace+doToggle, newStyle, false, theDocument^.theText); 
  1052.             END;
  1053.         
  1054.         newStyle.tsFace :=  offStyle;
  1055.         TESetStyle(doFace+doToggle, newStyle, (onStyle=[]), theDocument^.theText); (* Toggle all to off *)
  1056.         
  1057.         mode := doFace;
  1058.         
  1059.         IF (onStyle<>[]) THEN
  1060.           BEGIN
  1061.                 wasContinuous := TEContinuousStyle(mode, newStyle, theDocument^.theText);
  1062.                 IF ((newStyle.tsFace * onStyle) <> onStyle) THEN (* are they on for only a few chars *)
  1063.                     BEGIN
  1064.                         (* Need to make all chars have these characteristics *)
  1065.                     
  1066.                         newStyle.tsFace := onStyle - (newStyle.tsFace * onStyle); (* take out those continuous *)
  1067.                         TESetStyle(doFace+doToggle, newStyle, true, theDocument^.theText);
  1068.                     END
  1069.                 ELSE
  1070.                     TESetStyle(0, newStyle, true, theDocument^.theText); (* Just Draw it, no changes *)
  1071.           END;
  1072.         
  1073.         AdjustScrollbars(theDocument, FALSE);
  1074.         DrawPageExtras(theDocument);
  1075.         theDocument^.dirty := TRUE;
  1076.         
  1077.         SetPort(oldPort);
  1078.     END; (* SetTheStyleOfTheTokenText *)
  1079.  
  1080. { -----------------------------------------------------------------------
  1081.         Name:             SetWindowProperty
  1082.         Purpose:        Sets the window property specified in theWPTokenDesc to
  1083.                                 be that supplied in dataDesc.
  1084.      -----------------------------------------------------------------------*}
  1085.      
  1086. FUNCTION SetWindowProperty(theWPTokenDesc:AEDesc; dataDesc:AEDesc):OSErr;
  1087.     VAR theNewName           : Str255;
  1088.             theDocument        : DPtr;
  1089.             err                           : OSErr;
  1090.             ignoreErr            : OSErr;
  1091.             thePosnRect        : Rect;
  1092.             theBoolean         : Boolean;
  1093.             theHTE                   : TEHandle;
  1094.             oldPort                   : GrafPtr;
  1095.             thePosn            : Point;
  1096.             theTHPrint           : THPrint;
  1097.             theWindowPropToken : windowPropToken;
  1098.             newDesc            : AEDesc;
  1099.             tokenSize          : Size;
  1100.             tokenDesc          : AEDesc;
  1101.             myTextToken        : TextToken;
  1102.             hOffset            : INTEGER;
  1103.             vOffset            : INTEGER;
  1104.     
  1105.     BEGIN
  1106.         err := AECoerceDesc(theWPTokenDesc,typeMyWindowProp, newDesc);
  1107.         
  1108.         IF (err<>noErr) THEN
  1109.             BEGIN
  1110.                 SetWindowProperty := err;
  1111.                 Exit(SetWindowProperty);
  1112.             END;
  1113.  
  1114.         GetRawDataFromDescriptor(newDesc,
  1115.                                                          @theWindowPropToken,
  1116.                                                          SizeOf(theWindowPropToken),
  1117.                                                          tokenSize);
  1118.                                                          
  1119.         err := AEDisposeDesc(newDesc);
  1120.             
  1121.         GetPort(oldPort);
  1122.         SetPort(theWindowPropToken.tokenWindowToken);
  1123.         
  1124.         theDocument := DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1125.         
  1126.         IF (theWindowPropToken.tokenProperty = pName) THEN
  1127.             BEGIN
  1128.                 err := GetPStringFromDescriptor(dataDesc, theNewName);
  1129.                 IF (err=noErr) THEN
  1130.                     IF (theNewName = '') THEN
  1131.                         err := errAEWrongDataType
  1132.                     ELSE
  1133.                         BEGIN
  1134.                             SetWTitle(theWindowPropToken.tokenWindowToken, theNewName);
  1135.                             theDocument^.theFileName := theNewName;
  1136.                             theDocument^.dirty := TRUE;
  1137.                         END;
  1138.             END;
  1139.             
  1140.         IF (theWindowPropToken.tokenProperty = pText) THEN
  1141.             BEGIN
  1142.                 theHTE:=theDocument^.theText;
  1143.                 TESetSelect(0, 32000, theHTE);
  1144.                 
  1145.                 DoTEDeleteSectionRecalc(theDocument);
  1146.                 TEDelete(theHTE);
  1147.                 
  1148.                 err := GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1149.  
  1150.                 theDocument^.dirty := true;
  1151.             END;
  1152.             
  1153.         IF (theWindowPropToken.tokenProperty = pBounds) THEN
  1154.             BEGIN
  1155.                 err := GetRectFromDescriptor(dataDesc, thePosnRect);
  1156.                  WITH thePosnRect DO
  1157.                     BEGIN
  1158.                     { the rectangle is for the structure region, and is in global coordinates }
  1159.                     { MoveWindow and SizeWindow apply to the content region, so we have to massage a little }
  1160.                     { the massage is specific to the type of window we are using }
  1161.                     
  1162.                         thePosnRect.top    := thePosnRect.top +
  1163.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.contRgn^^.rgnBBox.top -
  1164.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.top;
  1165.                                                                     
  1166.                         thePosnRect.left   := thePosnRect.left +
  1167.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.contRgn^^.rgnBBox.left -
  1168.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.left;
  1169.                                                                     
  1170.                         thePosnRect.bottom := thePosnRect.bottom +
  1171.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.contRgn^^.rgnBBox.bottom -
  1172.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.bottom;
  1173.                                                                     
  1174.                         thePosnRect.right  := thePosnRect.right +
  1175.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.contRgn^^.rgnBBox.right -
  1176.                                                                     WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.right;
  1177.                                                                 
  1178.                         
  1179.                         IF EmptyRect(thePosnRect) THEN
  1180.                             err := errAECorruptData
  1181.                         ELSE
  1182.                             BEGIN
  1183.                                 MoveWindow(theWindowPropToken.tokenWindowToken,
  1184.                                                      thePosnRect.left,
  1185.                                                      thePosnRect.top,
  1186.                                                      FALSE);
  1187.                                 SizeWindow(theWindowPropToken.tokenWindowToken,
  1188.                                                      thePosnRect.right- thePosnRect.left,
  1189.                                                      thePosnRect.bottom-thePosnRect.top,
  1190.                                                      TRUE);
  1191.                                 ResizeWindow(theDocument);
  1192.                             END;
  1193.                 END;
  1194.             END;
  1195.  
  1196.         IF (theWindowPropToken.tokenProperty = pPosition) THEN
  1197.             BEGIN
  1198.                 err := GetPointFromDescriptor(dataDesc, thePosn);
  1199.                 { the point is for the structure region, and is in global coordinates }
  1200.                 { MoveWindow applies to the content region, so we have to massage a little }
  1201.                                                             
  1202.                 hOffset :=    WindowPeek(theWindowPropToken.tokenWindowToken)^.contRgn^^.rgnBBox.left -
  1203.                                         WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.left;
  1204.                 
  1205.                 vOffset :=    WindowPeek(theWindowPropToken.tokenWindowToken)^.contRgn^^.rgnBBox.top -
  1206.                                         WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.top;
  1207.                 
  1208.                 thePosn.v := thePosn.v + vOffset;
  1209.                 thePosn.h := thePosn.h + hOffset;
  1210.                 
  1211.                 MoveWindow(theWindowPropToken.tokenWindowToken,
  1212.                                      thePosn.h,
  1213.                                      thePosn.v,
  1214.                                      FALSE);
  1215.                                      
  1216.                 ResizeWindow(theDocument);
  1217.             END;
  1218.  
  1219.         IF (theWindowPropToken.tokenProperty = pIsZoomed) THEN
  1220.             BEGIN
  1221.                 err := GetBooleanFromDescriptor(dataDesc, theBoolean);
  1222.                 IF theBoolean THEN
  1223.                     ZoomWindow(thePort,
  1224.                                          inZoomOut,
  1225.                                          FALSE)
  1226.                 ELSE
  1227.                     ZoomWindow(thePort,
  1228.                                          inZoomIn,
  1229.                                          FALSE);
  1230.                                                          
  1231.                 ResizeWindow(theDocument);
  1232.             END;
  1233.             
  1234.         IF (theWindowPropToken.tokenProperty = pVisible) THEN
  1235.             BEGIN
  1236.                 err := GetBooleanFromDescriptor(dataDesc, theBoolean);
  1237.                 IF theBoolean THEN
  1238.                     ShowWindow(theWindowPropToken.tokenWindowToken)
  1239.                 ELSE
  1240.                     HideWindow(theWindowPropToken.tokenWindowToken);
  1241.             END;
  1242.             
  1243.         IF (theWindowPropToken.tokenProperty = pPageSetup) THEN
  1244.             BEGIN
  1245.                 err := GetTHPrintFromDescriptor(dataDesc,theTHPrint);
  1246.                     
  1247.                 IF (theTHPrint<>NIL) THEN
  1248.                     BEGIN
  1249.                         IF (theDocument^.thePrintSetup <> NIL) THEN
  1250.                             DisposHandle(Handle(theDocument^.thePrintSetup));
  1251.                             
  1252.                         theDocument^.thePrintSetup := theTHPrint;
  1253.                         
  1254.                         ResizePageSetupForDocument(theDocument);
  1255.                     END;
  1256.                                 
  1257.             END;
  1258.             
  1259.         IF (theWindowPropToken.tokenProperty = pShowBorders) THEN
  1260.             BEGIN
  1261.                 err := GetBooleanFromDescriptor(dataDesc, theBoolean);
  1262.                 theDocument^.showBorders := theBoolean;
  1263.                 IF theBoolean THEN
  1264.                     DrawPageExtras(theDocument) (* Does the clipping as well as drawing borders/page breaks *)
  1265.                 ELSE
  1266.                     InvalidateDocument(theDocument);
  1267.             END;
  1268.             
  1269.         IF (theWindowPropToken.tokenProperty = pSelection) THEN
  1270.             BEGIN                    
  1271.                 err := AECoerceDesc(dataDesc, typeMyText, tokenDesc);
  1272.                 
  1273.                 GetRawDataFromDescriptor(tokenDesc,
  1274.                                                                  Ptr(@myTextToken),
  1275.                                                                  sizeof(myTextToken),
  1276.                                                                  tokenSize);
  1277.                                                                                  
  1278.                 ignoreErr := AEDisposeDesc(tokenDesc);
  1279.                 
  1280.                 IF (err = noErr) THEN
  1281.                     BEGIN
  1282.                         (* got a text token *)
  1283.                         
  1284.                         theDocument := DPtrFromWindowPtr(myTextToken.tokenWindow);
  1285.                         theHTE      := theDocument^.theText;
  1286.                         
  1287.                         TESetSelect(myTextToken.tokenOffset-1,
  1288.                                                 myTextToken.tokenOffset+myTextToken.tokenLength-1,
  1289.                                                 theHTE);
  1290.                     END;
  1291.             END;
  1292.             
  1293.         IF (theWindowPropToken.tokenProperty = pIndex)       OR
  1294.              (theWindowPropToken.tokenProperty = pIsModal)     OR
  1295.              (theWindowPropToken.tokenProperty = pIsResizable) OR
  1296.              (theWindowPropToken.tokenProperty = pHasTitleBar) OR
  1297.              (theWindowPropToken.tokenProperty = pHasCloseBox) OR
  1298.              (theWindowPropToken.tokenProperty = pIsFloating)  OR
  1299.              (theWindowPropToken.tokenProperty = pIsZoomable)  OR
  1300.              (theWindowPropToken.tokenProperty = pIsModified)  THEN
  1301.             BEGIN
  1302.                 err := errAEEventNotHandled; (* We don't allow these to be set *)
  1303.             END;
  1304.         
  1305.         SetPort(oldPort);
  1306.         
  1307.         SetWindowProperty := err;
  1308.                 
  1309.     END; (* SetWindowProperty *)
  1310.     
  1311. { -----------------------------------------------------------------------
  1312.         Name:             AddDescStyleItem
  1313.         Purpose:        Adds the kAEXXXX style to theStyle.
  1314.      -----------------------------------------------------------------------*}
  1315.      
  1316. PROCEDURE AddDescStyleItem(theDesc: DescType; VAR theStyle:Style);
  1317.     VAR ctr             : StyleItem;
  1318.     
  1319.     BEGIN
  1320.         IF theDesc = kAEBold THEN
  1321.             theStyle := theStyle+[bold]
  1322.         ELSE
  1323.         IF theDesc = kAEItalic THEN
  1324.             theStyle := theStyle+[italic]
  1325.         ELSE
  1326.         IF theDesc = kAEUnderline THEN
  1327.             theStyle := theStyle+[underline]
  1328.         ELSE
  1329.         IF theDesc = kAEOutline THEN
  1330.             theStyle := theStyle+[outline]
  1331.         ELSE
  1332.         IF theDesc = kAEShadow THEN
  1333.             theStyle := theStyle+[shadow]
  1334.         ELSE
  1335.         IF theDesc = kAECondensed THEN
  1336.             theStyle := theStyle+[condense]
  1337.         ELSE
  1338.         IF theDesc = kAEExpanded THEN
  1339.             theStyle := theStyle+[extend]
  1340.         ELSE
  1341.         IF theDesc = kAEPlain THEN
  1342.             theStyle := [];
  1343.     END; (* AddDescStyleItem *)
  1344.     
  1345. FUNCTION MakeStyleFromAEList(styleList : AEDescList; VAR theStyle : Style; VAR hadPlain:BOOLEAN):OSErr;
  1346.     VAR myErr       : OSErr;
  1347.         styleDesc   : DescType;
  1348.             itemsInList : LongInt;
  1349.             actSize     : LongInt;
  1350.             keywd       : AEKeyWord;
  1351.             typeCode    : DescType;
  1352.             
  1353.     BEGIN
  1354.         hadPlain := FALSE;
  1355.         theStyle := [];
  1356.         
  1357.       myErr := AECountItems(styleList, itemsInList);
  1358.         WHILE (itemsInList>0) DO
  1359.           IF (myErr=noErr) THEN
  1360.                 BEGIN
  1361.                     myErr := AEGetNthPtr(styleList,
  1362.                                                              itemsInList,
  1363.                                                              typeEnumerated,
  1364.                                                              keywd,
  1365.                                                              typeCode,
  1366.                                                              @styleDesc,
  1367.                                                              sizeof(styleDesc),
  1368.                                                              actSize);
  1369.                     
  1370.                     AddDescStyleItem(styleDesc, theStyle);
  1371.                     
  1372.                     IF (styleDesc = kAEPlain) THEN
  1373.                       BEGIN
  1374.                             itemsInList := 0;
  1375.                             hadPlain    := TRUE;
  1376.                         END
  1377.                     ELSE
  1378.                       itemsInList := itemsInList - 1;
  1379.                 END;
  1380.                 
  1381.         MakeStyleFromAEList := myErr;
  1382.     END; (*MakeStyleFromAEList*)
  1383.     
  1384. FUNCTION GetTextStyles(dataDesc:AEDesc; VAR onStyles:Style; VAR offStyles:Style):OSErr;
  1385.     VAR myErr     : OSErr;
  1386.         ignoreErr : OSErr;
  1387.             textSDesc : AEDescList;
  1388.             onDesc    : AEDescList;
  1389.             offDesc   : AEDescList;
  1390.             hadPlain  : BOOLEAN;
  1391.             
  1392.     BEGIN
  1393.       textSDesc.dataHandle := NIL;
  1394.       onDesc.dataHandle    := NIL;
  1395.       offDesc.dataHandle   := NIL;
  1396.         
  1397.         onStyles  := [];
  1398.         offStyles := [];
  1399.         
  1400.       myErr := AECoerceDesc(dataDesc, typeAERecord, textSDesc);
  1401.         
  1402.         IF (myErr=noErr) THEN
  1403.           myErr := AEGetKeyDesc(textSDesc, keyAEOnStyles, typeAEList, onDesc);
  1404.         
  1405.         IF (myErr=noErr) THEN
  1406.           myErr := AEGetKeyDesc(textSDesc, keyAEOffStyles, typeAEList, offDesc);
  1407.         
  1408.         IF (myErr=noErr) THEN
  1409.             myErr := MakeStyleFromAEList(onDesc, onStyles, hadPlain);
  1410.         
  1411.         IF (hadPlain) THEN
  1412.             offStyles := [bold,italic,underline,outline,shadow,condense,extend]
  1413.         ELSE
  1414.             BEGIN
  1415.                 IF (myErr=noErr) THEN
  1416.                     myErr := MakeStyleFromAEList(offDesc, offStyles, hadPlain);
  1417.                     
  1418.                 IF (hadPlain) THEN
  1419.                     myErr := errAEEventFailed;
  1420.             END;
  1421.             
  1422.         IF (textSDesc.dataHandle<>NIL) THEN
  1423.             ignoreErr := AEDisposeDesc(textSDesc);
  1424.             
  1425.         IF (onDesc.dataHandle<>NIL) THEN
  1426.             ignoreErr := AEDisposeDesc(onDesc);
  1427.             
  1428.         IF (offDesc.dataHandle<>NIL) THEN
  1429.             ignoreErr := AEDisposeDesc(offDesc);
  1430.         
  1431.         GetTextStyles := myErr;
  1432.     END; (* GetTextStyles *)
  1433.     
  1434. { -----------------------------------------------------------------------
  1435.         Name:             SetTextProperty
  1436.         Purpose:        Sets the text property specfied by theTextPropToken to
  1437.                                 that in dataDesc.
  1438.      -----------------------------------------------------------------------*}
  1439.      
  1440. FUNCTION SetTextProperty(tokenDesc: AEDesc; dataDesc:AEDesc):OSErr;
  1441.     VAR theHTE                : TEHandle;
  1442.             theDoc           : DPtr;
  1443.             name                   : Str255;
  1444.             theSize               : INTEGER;
  1445.             myErr                   : OSErr;
  1446.           onStyle          : Style;
  1447.           offStyle         : Style;
  1448.           theTextPropToken : textPropToken;
  1449.           newDesc          : AEDesc;
  1450.           tokenSize        : Size;
  1451.             
  1452.     BEGIN
  1453.       newDesc.dataHandle := NIL;
  1454.         
  1455.       myErr := AECoerceDesc(tokenDesc,typeMyTextProp, newDesc);
  1456.         IF (myErr = noErr) THEN
  1457.             BEGIN
  1458.                 GetRawDataFromDescriptor(newDesc,
  1459.                                                                  @theTextPropToken,
  1460.                                                                  SizeOf(theTextPropToken),
  1461.                                                                  tokenSize);
  1462.                 myErr := AEDisposeDesc(newDesc);
  1463.             END
  1464.         ELSE
  1465.             BEGIN
  1466.                 SetTextProperty := myErr;
  1467.               Exit(SetTextProperty);
  1468.             END;
  1469.             
  1470.         theDoc := DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1471.         theDoc^.dirty := TRUE;
  1472.         
  1473.         IF (theTextPropToken.propertyProperty = pText) THEN
  1474.             BEGIN
  1475.                 theHTE := theDoc^.theText;
  1476.                 TESetSelect(theTextPropToken.propertyTextToken.tokenOffset-1,
  1477.                                         theTextPropToken.propertyTextToken.tokenOffset+
  1478.                                                                 theTextPropToken.propertyTextToken.tokenLength-1,
  1479.                                         theHTE);
  1480.                 
  1481.                 DoTEDeleteSectionRecalc(theDoc);
  1482.                 TEDelete(theHTE);
  1483.                 
  1484.                 myErr := GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1485.  
  1486.                 SetTextProperty := myErr;
  1487.                 Exit(SetTextProperty);
  1488.             END;
  1489.             
  1490.         IF (theTextPropToken.propertyProperty = pFont) THEN
  1491.             BEGIN                    
  1492.                 myErr := GetPStringFromDescriptor(dataDesc, name);
  1493.                 
  1494.                 SetTheFontOfTheTokenText(theTextPropToken.propertyTextToken,
  1495.                                                                  name);
  1496.                 
  1497.                 SetTextProperty:=noErr;
  1498.                 Exit(SetTextProperty);
  1499.             END;
  1500.             
  1501.         IF (theTextPropToken.propertyProperty = pPointSize) THEN
  1502.             BEGIN
  1503.                 myErr := GetIntegerFromDescriptor(dataDesc, theSize);
  1504.                 SetTheSizeOfTheTokenText(theTextPropToken.propertyTextToken,
  1505.                                                                  theSize);
  1506.                 
  1507.                 SetTextProperty := noErr;
  1508.                 Exit(SetTextProperty);
  1509.             END;
  1510.             
  1511.         IF (theTextPropToken.propertyProperty = pTextStyles) THEN
  1512.             BEGIN
  1513.                 onStyle  := [];
  1514.                 offStyle := [];
  1515.                 
  1516.                 myErr := GetTextStyles(dataDesc, onStyle, offStyle);
  1517.  
  1518.         IF (onStyle*offStyle<>[]) THEN
  1519.                     myErr := errAEEventFailed
  1520.                 ELSE
  1521.                     SetTheStyleOfTheTokenText(theTextPropToken.propertyTextToken,
  1522.                                                                         onStyle, 
  1523.                                                                         offStyle);
  1524.                 
  1525.                 SetTextProperty := myErr;
  1526.                 Exit(SetTextProperty);
  1527.             END;
  1528.                         
  1529.         SetTextProperty := errAEWrongDataType;
  1530.             
  1531.     END; (* SetTextProperty *)
  1532.     
  1533. { -----------------------------------------------------------------------
  1534.         Name:             HandleSetData
  1535.         Purpose:        Resolves the object into a token (could be one of many) and
  1536.                                 the sets the data of that object to dataDesc.
  1537.      -----------------------------------------------------------------------*}
  1538.      
  1539. FUNCTION HandleSetData(theObj: AEDesc; dataDesc: AEDesc): OSErr;
  1540. VAR myErr                            : OSErr;
  1541.         newDesc                        : AEDesc;
  1542.         theDocument       : DPtr;
  1543.         theHTE                    : TEHandle;
  1544.         theTextToken        : textToken;
  1545.         tokenSize         : Size;
  1546.         objTokenDesc      : AEDesc;
  1547.         ignoreErr         : OSErr;
  1548.         
  1549. BEGIN        
  1550.     objTokenDesc.dataHandle := NIL;
  1551.     newDesc.dataHandle := NIL;
  1552.     
  1553.     (*
  1554.         Coerce theObj into a token which we can use - 
  1555.             then set the property or data for that token
  1556.     *)
  1557.     
  1558.     myErr:= AEResolve(theObj ,kAEIDoMinimum, objTokenDesc);
  1559.     
  1560.     (* We don't actually allow ANY app property setting, but
  1561.        just incase we'll decode looking for an typeMyApplProp and flag an error
  1562.     *)
  1563.   
  1564.     IF (objTokenDesc.descriptorType = typeMyApplProp) OR
  1565.        (objTokenDesc.descriptorType = typeMyMenu    ) OR
  1566.        (objTokenDesc.descriptorType = typeMyMenuProp) OR
  1567.        (objTokenDesc.descriptorType = typeMyMenuItem) OR
  1568.        (objTokenDesc.descriptorType = typeMyItemProp) THEN
  1569.         myErr := errAEWrongDataType
  1570.     ELSE
  1571.     IF (objTokenDesc.descriptorType = typeMyWindowProp) THEN
  1572.         myErr := SetWindowProperty(objTokenDesc, dataDesc)
  1573.     ELSE
  1574.     IF (objTokenDesc.descriptorType = typeMyTextProp) THEN
  1575.         myErr := SetTextProperty(objTokenDesc, dataDesc)
  1576.     ELSE
  1577.     IF (objTokenDesc.descriptorType = typeMyText) THEN
  1578.         IF AECoerceDesc(objTokenDesc,typeMyText,newDesc) = noErr THEN
  1579.             BEGIN
  1580.                 GetRawDataFromDescriptor(newDesc,
  1581.                                                                  @theTextToken,
  1582.                                                                  SizeOf(theTextToken),
  1583.                                                                  tokenSize);
  1584.                                                                  
  1585.                 theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  1586.                 theHTE            := theDocument^.theText;
  1587.                 
  1588.                 TESetSelect(theTextToken.tokenOffset-1,
  1589.                                         theTextToken.tokenOffset+
  1590.                                                                 theTextToken.tokenLength-1,
  1591.                                         theHTE);
  1592.                 
  1593.                 DoTEDeleteSectionRecalc(theDocument);
  1594.                 TEDelete(theHTE);
  1595.                 
  1596.                 myErr := GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1597.                                 
  1598.                 theDocument^.dirty := TRUE;
  1599.             END;
  1600.             
  1601.     IF (objTokenDesc.dataHandle<>NIL) THEN
  1602.         ignoreErr:=AEDisposeDesc(objTokenDesc);
  1603.     
  1604.     HandleSetData := myErr;
  1605.     
  1606. END;    { HandleSetData }
  1607.  
  1608. (*
  1609.     A few convenient FORWARDS...
  1610. *)
  1611.  
  1612. FUNCTION MakeWindowObj( theWindow  : WindowPtr;
  1613.                                                 VAR dMyDoc : AEDesc):OSErr; FORWARD;
  1614.  
  1615. FUNCTION MakeSelTextObj(theWindow         : WindowPtr;
  1616.                                               theTextEditHandle : TEHandle; 
  1617.                                                 VAR selTextObj    : AEDesc): OSErr;
  1618. VAR 
  1619.     myErr            : OSErr;
  1620.     ignoreErr    : OSErr;
  1621.     dNull     : AEDesc;
  1622.     dMyDoc    : AEDesc;
  1623.     startOfs    :    AEDesc;
  1624.     endOfs        : AEDesc;
  1625.     startObj    :    AEDesc;
  1626.     endObj        : AEDesc;
  1627.     rangeDesc    : AEDesc;
  1628.     startChar    :    LongInt;
  1629.     endChar        :    LongInt;
  1630.     spotFlag    :    BOOLEAN;
  1631.         
  1632. BEGIN
  1633.   myErr := noErr;
  1634.     
  1635.     IF (theWindow=nil) THEN
  1636.         BEGIN
  1637.             MakeSelTextObj:=noErr;
  1638.             Exit(MakeSelTextObj);
  1639.         END;
  1640.         
  1641.     selTextObj.dataHandle := nil;
  1642.     dMyDoc.dataHandle     := nil;
  1643.     startObj.dataHandle   := nil;
  1644.     endObj.dataHandle     := nil;
  1645.     
  1646.   (* 
  1647.         make the window object 
  1648.     *)
  1649.     
  1650.     myErr := MakeWindowObj(theWindow, dMyDoc);
  1651.         
  1652.   IF (myErr=noErr) THEN
  1653.         BEGIN
  1654.             { get the start and end of selection }
  1655.             
  1656.             WITH theTextEditHandle^^ DO
  1657.                 BEGIN
  1658.                     startChar := selStart+1;    { start counting obj's from 1, not 0 }
  1659.                     endChar   := selEnd;
  1660.                     spotFlag  := (selStart = selEnd);
  1661.                 END;
  1662.                 
  1663.             myErr := CreateOffsetDescriptor(startChar, startOfs);
  1664.                         
  1665.             IF myErr=noErr THEN
  1666.                 IF spotFlag THEN
  1667.                     myErr := CreateObjSpecifier( cSpot,
  1668.                                                                              dMyDoc,
  1669.                                                                              formAbsolutePosition, 
  1670.                                                                              startOfs, 
  1671.                                                                              TRUE, 
  1672.                                                                              selTextObj)
  1673.                 ELSE
  1674.                     BEGIN
  1675.                         { not a spot - must represent as range }
  1676.                         { make obj for start char }
  1677.                             
  1678.                         myErr := AECreateDesc(typeNull, nil , 0, dNull);
  1679.                         
  1680.                         myErr := CreateObjSpecifier(cChar, dNull, formAbsolutePosition, startOfs, FALSE, startObj);
  1681.                         
  1682.                         IF (myErr=noErr) THEN
  1683.                             myErr := CreateOffsetDescriptor(endChar, endOfs);
  1684.                         
  1685.                         IF (myErr=noErr) THEN
  1686.                             myErr := CreateObjSpecifier(cChar, dNull, formAbsolutePosition, endOfs, FALSE, endObj);
  1687.                         
  1688.                         IF (myErr=noErr) THEN
  1689.                             myErr := CreateRangeDescriptor(startObj,
  1690.                                                                                         endObj,
  1691.                                                                                         FALSE,
  1692.                                                                                         rangeDesc);
  1693.                         
  1694.                         if (myErr=noErr) then
  1695.                             BEGIN
  1696.                                 myErr := CreateObjSpecifier(cChar,
  1697.                                                                                         dMyDoc,
  1698.                                                                                         formRange,
  1699.                                                                                         rangeDesc,
  1700.                                                                                         TRUE,
  1701.                                                                                         selTextObj);
  1702.                             
  1703.                             END;
  1704.                             
  1705.                         IF (startObj.dataHandle<>NIL) THEN
  1706.                             myErr := AEDisposeDesc(startObj);
  1707.                             
  1708.                         IF (endObj.dataHandle<>NIL) THEN
  1709.                             myErr := AEDisposeDesc(endObj);
  1710.                             
  1711.                         IF (startOfs.dataHandle<>NIL) THEN
  1712.                             myErr := AEDisposeDesc(startOfs);
  1713.                             
  1714.                         IF (endOfs.dataHandle<>NIL) THEN
  1715.                             myErr := AEDisposeDesc(endOfs);
  1716.                     END;
  1717.          END;
  1718.       
  1719.   MakeSelTextObj := myErr;
  1720. END;    { MakeSelTextObj }
  1721.                                             
  1722. { -----------------------------------------------------------------------
  1723.         Name:             DoSetData
  1724.         Purpose:        Handles the SetData Apple Event, extracting the direct
  1725.                                 object (which says what to set) and the data (what to set
  1726.                                 it to).
  1727.      -----------------------------------------------------------------------*}
  1728.      
  1729. FUNCTION DoSetData(theAppleEvent    : AppleEvent;
  1730.                                      reply                    : AppleEvent;
  1731.                                      handlerRefCon    : LongInt): OSErr;
  1732. VAR 
  1733.     myErr                : OSErr;
  1734.     ignoreErr   : OSErr;
  1735.     myDirObj        : AEDesc;
  1736.     myDataDesc    : AEDesc;
  1737.     
  1738. BEGIN
  1739.   myDataDesc.dataHandle := NIL;
  1740.     myDirObj.dataHandle   := NIL;
  1741.     
  1742.   { pick up the direct object, which is the object whose data is to be set }
  1743.     
  1744.   myErr := AEGetParamDesc(theAppleEvent,
  1745.                                                   keyDirectObject,
  1746.                                                     typeWildCard,
  1747.                                                     myDirObj);
  1748.       
  1749.   { now the data to set it to - typeWildCard means get as is}
  1750.   IF (myErr = noErr) THEN
  1751.       myErr := AEGetParamDesc(theAppleEvent,
  1752.                                                         keyAEData,
  1753.                                                         typeWildCard,
  1754.                                                         myDataDesc);
  1755.   
  1756.   { missing any parameters? }
  1757.   IF (myErr = noErr) THEN
  1758.       myErr := GotRequiredParams(theAppleEvent);
  1759.   
  1760.   { set the data }
  1761.   IF (myErr = noErr) THEN
  1762.         myErr := HandleSetData(myDirObj,myDataDesc);
  1763.         
  1764.     IF (myDataDesc.dataHandle<>NIL) THEN
  1765.         ignoreErr := AEDisposeDesc(myDataDesc);
  1766.         
  1767.     IF (myDirObj.dataHandle<>NIL) THEN
  1768.         ignoreErr := AEDisposeDesc(myDirObj);
  1769.   
  1770.   DoSetData := myErr;
  1771. END;    { DoSetData }
  1772.  
  1773. PROCEDURE StyleTokConst(theStyleItem:StyleItem; VAR thekConst:DescType);
  1774.     BEGIN
  1775.         CASE theStyleItem OF
  1776.           bold      : thekConst := kAEBold;
  1777.       italic    : thekConst := kAEItalic;
  1778.       underline : thekConst := kAEUnderline;
  1779.       outline   : thekConst := kAEOutline;
  1780.             shadow    : thekConst := kAEShadow;
  1781.             condense  : thekConst := kAECondensed;
  1782.             extend    : thekConst := kAEExpanded;
  1783.         END;
  1784.     END; (*StyleTokConst*)
  1785.  
  1786. { -----------------------------------------------------------------------
  1787.         Name:             BuildTypeTextStylesDesc
  1788.         Purpose:        Given on and off styles, BuildTextStylesDesc creates an typeTextStyles 
  1789.                     descriptor record containing a pair of lists, keyAEOnStyles
  1790.                                 and keyAEOffStyles. keyAEOffStyles contains all the styles
  1791.                                 we support that are not in theStyle.
  1792.      -----------------------------------------------------------------------*}
  1793.      
  1794. FUNCTION BuildTypeTextStylesDesc(onStyles,offStyles :Style; VAR resultDesc: AEDesc):OSErr;
  1795.     VAR
  1796.             myErr                  : OSErr;
  1797.             ignoreErr          : OSErr;
  1798.             myStyleItem      : styleItem;
  1799.             styleConst    : DescType;
  1800.             onStylesDesc  : AEDesc;
  1801.             offStylesDesc : AEDesc;
  1802.             dataDesc      : AEDesc;
  1803.             
  1804.     BEGIN
  1805.         onStylesDesc.dataHandle  := NIL;
  1806.         offStylesDesc.dataHandle := NIL;
  1807.         dataDesc.dataHandle  := NIL;
  1808.     
  1809.         myErr := AECreateList(NIL, 0, TRUE, dataDesc);
  1810.         
  1811.         myErr := AECreateList(NIL, 0, FALSE, onStylesDesc);
  1812.         myErr := AECreateList(NIL, 0, FALSE, offStylesDesc);
  1813.         
  1814.         FOR myStyleItem := bold TO extend DO
  1815.             IF (myErr=noErr) THEN
  1816.                 BEGIN
  1817.                     StyleTokConst(myStyleItem, styleConst);
  1818.                     IF (myStyleItem IN onStyles) THEN
  1819.                         myErr := AEPutPtr(onStylesDesc,
  1820.                                                             0,                {add to end of list}
  1821.                                                             typeEnumerated, { text for style name }
  1822.                                                             @styleConst,
  1823.                                                             sizeof(styleConst));
  1824.                                                             
  1825.                     IF (myStyleItem IN offStyles) THEN
  1826.                         myErr := AEPutPtr(offStylesDesc,
  1827.                                                             0,                {add to end of list}
  1828.                                                             typeEnumerated, { text for style name }
  1829.                                                             @styleConst,
  1830.                                                             sizeof(styleConst))
  1831.             END;
  1832.         
  1833.         IF (myErr=noErr) THEN
  1834.             myErr := AEPutKeyDesc(dataDesc, keyAEOnStyles,  onStylesDesc);
  1835.         
  1836.         IF (myErr=noErr) THEN
  1837.             myErr := AEPutKeyDesc(dataDesc, keyAEOffStyles, offStylesDesc);
  1838.         
  1839.         IF (myErr=noErr) THEN
  1840.             myErr := AECoerceDesc(dataDesc, typeTextStyles, resultDesc);
  1841.             
  1842.         IF (onStylesDesc.dataHandle <> NIL) THEN
  1843.             ignoreErr := AEDisposeDesc(onStylesDesc);
  1844.             
  1845.         IF (offStylesDesc.dataHandle <> NIL) THEN
  1846.             ignoreErr := AEDisposeDesc(offStylesDesc);
  1847.             
  1848.         IF (dataDesc.dataHandle <> NIL) THEN
  1849.             ignoreErr := AEDisposeDesc(dataDesc);
  1850.     
  1851.         BuildTypeTextStylesDesc := myErr;
  1852.     END; (* BuildTextStylesDesc *)
  1853.  
  1854. FUNCTION BuildTextStylesDesc(theStyle : Style; VAR resultDesc:AEDesc) : OSErr;
  1855.     VAR
  1856.         myStyleItem : StyleItem;
  1857.         onStyles    : Style;
  1858.         offStyles   : Style;
  1859.                 
  1860.     BEGIN
  1861.         onStyles  := [];
  1862.         offStyles := [];
  1863.         
  1864.         FOR myStyleItem := bold TO extend DO
  1865.             BEGIN
  1866.                 IF (myStyleItem IN theStyle) THEN
  1867.                     onStyles  := onStyles  + [myStyleItem]
  1868.                 ELSE
  1869.                     offStyles := offStyles + [myStyleItem];
  1870.             END;
  1871.     
  1872.         BuildTextStylesDesc := BuildTypeTextStylesDesc(onStyles, offStyles, resultDesc);
  1873.         
  1874.     END; (* BuildTextStylesDesc *)
  1875.         
  1876. FUNCTION BuildStyledTextDesc(theHTE : TEHandle; start:INTEGER; howLong:INTEGER; VAR resultDesc:AEDesc):OSErr;
  1877.     VAR
  1878.         listDesc         : AEDesc;
  1879.         oldSelStart      : INTEGER;
  1880.         oldSelEnd        : INTEGER;
  1881.         myStScrpHandle : StScrpHandle;
  1882.         myErr          : OSErr;
  1883.         ignoreErr      : OSErr;
  1884.         
  1885.     BEGIN
  1886.         listDesc.dataHandle := nil;
  1887.         
  1888.         oldSelStart := theHTE^^.selStart;
  1889.         oldSelEnd   := theHTE^^.selEnd;
  1890.         
  1891.         TESetSelect(start-1, start+howLong-2, theHTE);
  1892.         
  1893.         myErr := AECreateList(nil, 0, TRUE,  listDesc);
  1894.         
  1895.         HLock(Handle(theHTE^^.hText));
  1896.                                                          
  1897.         IF (myErr=noErr) THEN
  1898.             myErr := AEPutKeyPtr(listDesc,
  1899.                                  keyAEText,
  1900.                                                      typeChar,
  1901.                                                      Ptr(ORD4(@theHTE^^.hText^^)+start-1),
  1902.                                                      howLong);
  1903.                                                     
  1904.         HUnlock(Handle(theHTE^^.hText));
  1905.         
  1906.         myStScrpHandle := GetStylScrap(theHTE);
  1907.         
  1908.         IF (myStScrpHandle<>NIL) THEN
  1909.             BEGIN
  1910.                 HLock(Handle(myStScrpHandle));
  1911.                 
  1912.                 IF (myErr=noErr) THEN
  1913.                     myErr := AEPutKeyPtr(listDesc,
  1914.                                          keyAEStyles,
  1915.                                                              typeScrapStyles,
  1916.                                                              Ptr(myStScrpHandle^),
  1917.                                                              GetHandleSize(Handle(myStScrpHandle)));
  1918.                     
  1919.                 HUnlock(Handle(myStScrpHandle));
  1920.             END    
  1921.         ELSE
  1922.             myErr := AEPutKeyPtr(listDesc,
  1923.                                                      keyAEStyles,
  1924.                                                      typeScrapStyles,
  1925.                                                      NIL,
  1926.                                                      0);
  1927.         
  1928.         IF (myErr=noErr) THEN
  1929.             myErr := AECoerceDesc(listDesc, typeStyledText, resultDesc); (* should be typeIntlText *)
  1930.         
  1931.         IF (listDesc.dataHandle <> NIL) THEN
  1932.             ignoreErr := AEDisposeDesc(listDesc);
  1933.         
  1934.         TESetSelect(oldSelStart, oldSelEnd, theHTE);
  1935.         
  1936.         BuildStyledTextDesc := myErr;
  1937.     END;
  1938.     
  1939. { -----------------------------------------------------------------------
  1940.         Name:             GetTextProperty
  1941.         Purpose:        Fills dataDesc with the requested text property.
  1942.      -----------------------------------------------------------------------*}
  1943.      
  1944. FUNCTION GetTextProperty(theTokenDesc:AEDesc; VAR dataDesc: AEDesc):OSErr;
  1945.     VAR theDocument     : DPtr;
  1946.             theHTE                 : TEHandle;
  1947.             fontName           : Str255;
  1948.             theSize                : INTEGER;
  1949.             oldPort         : GrafPtr;
  1950.             theTextStyle    : TextStyle;
  1951.             lineHeight        : INTEGER;
  1952.             fontAscent        : INTEGER;
  1953.             theTextPropToken: textPropToken;
  1954.             newDesc         : AEDesc;
  1955.             myErr           : OSErr;
  1956.             tokenSize       : Longint;
  1957.             
  1958.     BEGIN
  1959.       myErr := AECoerceDesc(theTokenDesc, typeMyTextProp, newDesc);
  1960.         IF (myErr = noErr) THEN
  1961.             BEGIN
  1962.                 GetRawDataFromDescriptor(newDesc,
  1963.                                                                  @theTextPropToken,
  1964.                                                                  SizeOf(theTextPropToken),
  1965.                                                                  tokenSize);
  1966.                 myErr:= AEDisposeDesc(newDesc);                                                 
  1967.             END
  1968.         ELSE
  1969.           BEGIN
  1970.                 GetTextProperty := myErr;
  1971.                 Exit(GetTextProperty);
  1972.           END;
  1973.     
  1974.         (*
  1975.             For each property we build a descriptor to be returned as the reply.
  1976.         *)
  1977.                 
  1978.         theDocument := DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1979.         theHTE             := theDocument^.theText;
  1980.         
  1981.         TEGetStyle (theTextPropToken.propertyTextToken.tokenOffset-1,
  1982.                                 theTextStyle,
  1983.                                 lineHeight,
  1984.                                 fontAscent,
  1985.                                 theHTE);
  1986.                                         
  1987.         IF (theTextPropToken.propertyProperty = pText) THEN
  1988.             BEGIN
  1989.                 myErr := BuildStyledTextDesc( theHTE,
  1990.                                                                             theTextPropToken.propertyTextToken.tokenOffset,
  1991.                                                                             theTextPropToken.propertyTextToken.tokenLength,
  1992.                                                                             dataDesc);
  1993.             END
  1994.         ELSE
  1995.         
  1996.         IF (theTextPropToken.propertyProperty = pFont) THEN
  1997.             BEGIN
  1998.             
  1999.                 GetFontName(theTextStyle.tsFont, fontName);
  2000.                 
  2001.                 myErr := AECreateDesc(typeChar,
  2002.                                                             POINTER(ORD4(@fontName)+1),
  2003.                                                             length(fontName),
  2004.                                                             dataDesc);
  2005.             END
  2006.         ELSE
  2007.             
  2008.         IF (theTextPropToken.propertyProperty = pTextStyles) THEN
  2009.             BEGIN                                            
  2010.                 myErr := BuildTextStylesDesc(theTextStyle.tsFace, dataDesc);
  2011.             END
  2012.         ELSE
  2013.             
  2014.         IF (theTextPropToken.propertyProperty = pPointSize) THEN
  2015.             BEGIN
  2016.                 myErr := CreateOffsetDescriptor(theTextStyle.tsSize, dataDesc);
  2017.             END
  2018.         ELSE
  2019.             
  2020.         IF (theTextPropToken.propertyProperty = pScriptTag) THEN
  2021.             BEGIN
  2022.                 myErr := CreateOffsetDescriptor(smSystemScript, dataDesc);
  2023.             END
  2024.         ELSE
  2025.             
  2026.         IF (theTextPropToken.propertyProperty = pStringWidth) THEN
  2027.             BEGIN
  2028.                 GetPort(oldPort);
  2029.                 SetPort(theTextPropToken.propertyTextToken.tokenWindow);
  2030.                 
  2031.                 HLock(Handle(theHTE^^.hText));
  2032.                 theSize := TextWidth(@theHTE^^.hText,
  2033.                                                          theTextPropToken.propertyTextToken.tokenOffset-1,
  2034.                                                          theTextPropToken.propertyTextToken.tokenLength);
  2035.                 
  2036.                 HUnLock(Handle(theHTE^^.hText));
  2037.                 
  2038.                 SetPort(oldPort);
  2039.                 myErr := CreateOffsetDescriptor(theSize, dataDesc);
  2040.             END
  2041.         ELSE
  2042.         
  2043.         IF (theTextPropToken.propertyProperty = pColor) THEN
  2044.             BEGIN
  2045.                 myErr := AECreateDesc(typeRGBColor,
  2046.                                                             @theTextStyle.tsColor,
  2047.                                                             sizeof(theTextStyle.tsColor),
  2048.                                                             dataDesc);
  2049.             END
  2050.         ELSE
  2051.             myErr := errAEEventNotHandled;
  2052.         
  2053.         GetTextProperty := myErr;
  2054.     END; (*GetTextProperty*)
  2055.     
  2056. { -----------------------------------------------------------------------
  2057.         Name:             GetWindowProperty
  2058.         Purpose:        Fills dataDesc with the requested window property.
  2059.      -----------------------------------------------------------------------*}
  2060.      
  2061. FUNCTION GetWindowProperty(theWPTokenObj:AEDesc ;VAR dataDesc:AEDesc):OSErr;
  2062.     TYPE RectHandle = ^RectPtr;
  2063.              RectPtr    = ^Rect;
  2064.              
  2065.     VAR theErr                   : OSErr;
  2066.             theName                : Str255;
  2067.             theBoolean           : Boolean;
  2068.             theRect              : Rect;
  2069.             thePoint           : Point;
  2070.             winRect                   : Rect;
  2071.             userRect               : Rect;
  2072.             theIndex               : INTEGER;
  2073.             theDocument        : DPtr;
  2074.             theHTE                   : TEHandle;
  2075.             theWindowPropToken : windowPropToken;
  2076.             tokenSize          : Longint;
  2077.             newDesc            : AEDesc;
  2078.     
  2079.     BEGIN
  2080.       theErr := AECoerceDesc(theWPTokenObj,typeMyWindowProp,newDesc);
  2081.         
  2082.         IF (theErr = noErr) THEN
  2083.             BEGIN
  2084.                 GetRawDataFromDescriptor(newDesc,
  2085.                                                                  @theWindowPropToken,
  2086.                                                                  SizeOf(theWindowPropToken),
  2087.                                                                  tokenSize);
  2088.                                                                  
  2089.                 theErr := AEDisposeDesc(newDesc);
  2090.             END
  2091.         ELSE
  2092.           BEGIN
  2093.                 GetWindowProperty := theErr;
  2094.                 Exit(GetWindowProperty);
  2095.             END;
  2096.             
  2097.         IF (theWindowPropToken.tokenProperty = pName) THEN
  2098.             BEGIN
  2099.                 GetWTitle(theWindowPropToken.tokenWindowToken,theName);
  2100.                 theErr := AECreateDesc(typeChar,
  2101.                                                              Ptr(ORD4(@theName)+1),
  2102.                                                              Length(theName),
  2103.                                                              dataDesc);
  2104.             END
  2105.         ELSE
  2106.             
  2107.         IF (theWindowPropToken.tokenProperty = pText) THEN
  2108.             BEGIN
  2109.                 theDocument := DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2110.                 theHTE      := theDocument^.theText;
  2111.                 
  2112.                 theErr := BuildStyledTextDesc(theHTE,
  2113.                                                                             1,
  2114.                                                                             theHTE^^.teLength,
  2115.                                                                             dataDesc);
  2116.             END
  2117.         ELSE
  2118.             
  2119.         IF (theWindowPropToken.tokenProperty = pBounds) THEN
  2120.             BEGIN
  2121.                 SetPort(theWindowPropToken.tokenWindowToken);
  2122.                 
  2123.                 theRect := WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox;
  2124.                 
  2125.                 theErr := AECreateDesc(typeQDRectangle,
  2126.                                                              @theRect,
  2127.                                                              sizeOf(theRect),
  2128.                                                              dataDesc);
  2129.             END
  2130.         ELSE
  2131.             
  2132.         IF (theWindowPropToken.tokenProperty = pPosition) THEN
  2133.             BEGIN
  2134.                 thePoint := WindowPeek(theWindowPropToken.tokenWindowToken)^.strucRgn^^.rgnBBox.topLeft;
  2135.                             
  2136.                 theErr := AECreateDesc(typeQDPoint,
  2137.                                                              @thePoint,
  2138.                                                              sizeOf(thePoint),
  2139.                                                              dataDesc);
  2140.             END
  2141.         ELSE
  2142.                         
  2143.         IF (theWindowPropToken.tokenProperty = pVisible) THEN
  2144.             BEGIN
  2145.                 theBoolean := WindowPeek(theWindowPropToken.tokenWindowToken)^.visible;
  2146.                                 
  2147.                 theErr := AECreateDesc(typeBoolean,
  2148.                                                              @theBoolean,
  2149.                                                              sizeOf(theBoolean),
  2150.                                                              dataDesc);
  2151.             END
  2152.         ELSE
  2153.             
  2154.         IF (theWindowPropToken.tokenProperty = pIsModal) THEN
  2155.             BEGIN
  2156.                 theBoolean := FALSE;
  2157.                                 
  2158.                 theErr := AECreateDesc(typeBoolean,
  2159.                                                              @theBoolean,
  2160.                                                              sizeOf(theBoolean),
  2161.                                                              dataDesc);
  2162.             END
  2163.         ELSE
  2164.             
  2165.         IF (theWindowPropToken.tokenProperty = pShowBorders) THEN
  2166.             BEGIN
  2167.                 theDocument := DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2168.                 theBoolean  := theDocument^.showBorders;
  2169.                                 
  2170.                 theErr := AECreateDesc(typeBoolean,
  2171.                                                              @theBoolean,
  2172.                                                              sizeOf(theBoolean),
  2173.                                                              dataDesc);
  2174.             END
  2175.         ELSE
  2176.             
  2177.         IF (theWindowPropToken.tokenProperty = pIsZoomed) THEN
  2178.             BEGIN
  2179.                 IF (WindowPeek(theWindowPropToken.tokenWindowToken)^.spareFlag) THEN
  2180.                     BEGIN
  2181.                         SetPort(theWindowPropToken.tokenWindowToken);
  2182.                         
  2183.                         userRect := RectHandle(WindowPeek(thePort)^.dataHandle)^^;
  2184.                         winRect  := thePort^.portRect;
  2185.                         LocalToGlobal(winRect.topLeft);
  2186.                         LocalToGlobal(winRect.botRight);
  2187.                         
  2188.                         theBoolean := NOT EqualRect(userRect,winRect); (* right way?? - ***LATER *)
  2189.                         
  2190.                     END
  2191.                 ELSE
  2192.                     theBoolean := FALSE;
  2193.                                 
  2194.                 theErr := AECreateDesc(typeBoolean,
  2195.                                                              @theBoolean,
  2196.                                                              sizeOf(theBoolean),
  2197.                                                              dataDesc);
  2198.             END
  2199.         ELSE
  2200.             
  2201.         IF (theWindowPropToken.tokenProperty = pIsResizable) OR
  2202.            (theWindowPropToken.tokenProperty = pHasTitleBar) OR
  2203.            (theWindowPropToken.tokenProperty = pHasCloseBox) OR
  2204.            (theWindowPropToken.tokenProperty = pIsZoomable) THEN
  2205.              
  2206.             BEGIN
  2207.                 theBoolean := TRUE;
  2208.                                 
  2209.                 theErr := AECreateDesc(typeBoolean,
  2210.                                                              @theBoolean,
  2211.                                                              sizeOf(theBoolean),
  2212.                                                              dataDesc);
  2213.             END
  2214.         ELSE
  2215.         IF (theWindowPropToken.tokenProperty = pIsFloating) THEN
  2216.              
  2217.             BEGIN
  2218.                 theBoolean := FALSE;
  2219.                                 
  2220.                 theErr := AECreateDesc(typeBoolean,
  2221.                                                              @theBoolean,
  2222.                                                              sizeOf(theBoolean),
  2223.                                                              dataDesc);
  2224.             END
  2225.         ELSE
  2226.             
  2227.         IF (theWindowPropToken.tokenProperty = pIsModified) THEN
  2228.             BEGIN
  2229.                 theDocument := DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2230.                 
  2231.                 theBoolean  := theDocument^.dirty;
  2232.                 
  2233.                 theErr := AECreateDesc(typeBoolean,
  2234.                                                              @theBoolean,
  2235.                                                              sizeOf(theBoolean),
  2236.                                                              dataDesc);
  2237.             END
  2238.         ELSE
  2239.             
  2240.         IF (theWindowPropToken.tokenProperty = pIndex) THEN
  2241.             BEGIN
  2242.                 theIndex := 0;
  2243.                 IF (theWindowPropToken.tokenWindowToken<>nil) THEN
  2244.                     REPEAT
  2245.                         theIndex := theIndex+1;
  2246.                     UNTIL (theWindowPropToken.tokenWindowToken=GetWindowPtrOfNthWindow(theIndex));
  2247.                                 
  2248.                 theErr := AECreateDesc(typeShortInteger,
  2249.                                                              @theIndex,
  2250.                                                              sizeOf(theIndex),
  2251.                                                              dataDesc);
  2252.             END
  2253.         ELSE
  2254.             
  2255.         IF (theWindowPropToken.tokenProperty = pPageSetup) THEN
  2256.             BEGIN
  2257.                 theDocument := DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2258.                 
  2259.                 theErr := AECreateDesc(typeTPrint,
  2260.                                                              Ptr(theDocument^.thePrintSetup^),
  2261.                                                              SizeOf(TPrint),
  2262.                                                              dataDesc);
  2263.             END
  2264.         ELSE
  2265.           IF (theWindowPropToken.tokenProperty = pSelection) THEN
  2266.               BEGIN
  2267.                     theDocument := DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2268.                     
  2269.                     theErr  := MakeSelTextObj(theWindowPropToken.tokenWindowToken,
  2270.                                                                         theDocument^.theText, 
  2271.                                                                         dataDesc);                                                             
  2272.                 END
  2273.             ELSE
  2274.                 theErr := kAEGenericErr;
  2275.             
  2276.         GetWindowProperty := theErr;
  2277.     END; (* GetWindowProperty *)
  2278.     
  2279. {* -----------------------------------------------------------------------
  2280.         Name:             GetApplicationProperty
  2281.         Purpose:        Fills dataDesc with the requested application property.
  2282.      -----------------------------------------------------------------------*}
  2283.      
  2284. FUNCTION GetApplicationProperty(theTokenObj:AEDesc; VAR dataDesc: AEDesc): OSErr;
  2285.     VAR theErr           : OSErr;
  2286.             theName          : Str255;
  2287.             isFront          : Boolean;
  2288.             theApplPropToken : ApplPropToken;
  2289.             newDesc          : AEDesc;
  2290.             tokenSize                 : LongInt;
  2291.     
  2292.     BEGIN
  2293.         theErr := AECoerceDesc(theTokenObj,typeMyApplProp,newDesc);
  2294.         IF (theErr=noErr) THEN
  2295.             BEGIN
  2296.                 GetRawDataFromDescriptor(newDesc,
  2297.                                                                  @theApplPropToken,
  2298.                                                                  SizeOf(theApplPropToken),
  2299.                                                                  tokenSize);
  2300.                                                                  
  2301.                 theErr := AEDisposeDesc(newDesc);
  2302.             END
  2303.         ELSE
  2304.           BEGIN
  2305.             GetApplicationProperty := theErr;
  2306.                 Exit(GetApplicationProperty);            
  2307.             END;
  2308.     
  2309.         IF (theApplPropToken.tokenApplProperty = pName) THEN
  2310.             BEGIN
  2311.                 theName:= '7Edit';
  2312.                 theErr := AECreateDesc(typeChar,
  2313.                                                              Ptr(ORD4(@theName)+1),
  2314.                                                              Length(theName),
  2315.                                                              dataDesc);
  2316.             END
  2317.         ELSE
  2318.         IF (theApplPropToken.tokenApplProperty = pVersion) THEN
  2319.             BEGIN
  2320.                 theName:= '3.0d5';
  2321.                 theErr := AECreateDesc(typeChar,
  2322.                                                              Ptr(ORD4(@theName)+1),
  2323.                                                              Length(theName),
  2324.                                                              dataDesc);
  2325.             END
  2326.         ELSE        
  2327.         IF (theApplPropToken.tokenApplProperty = pIsFrontProcess) THEN
  2328.             BEGIN
  2329.                 isFront := NOT gInBackground;
  2330.                 theErr := AECreateDesc(typeBoolean,
  2331.                                                              @isFront,
  2332.                                                              sizeof(isFront),
  2333.                                                              dataDesc);
  2334.             END
  2335.         ELSE
  2336.             theErr := kAEGenericErr;
  2337.  
  2338.         GetApplicationProperty := theErr;
  2339.     END; (* GetApplicationProperty *)
  2340.     
  2341. (* -----------------------------------------------------------------------
  2342.         Name:             GetMenuProperty
  2343.         Purpose:        Fills dataDesc with the requested menu property.
  2344.      -----------------------------------------------------------------------**)
  2345.      
  2346. FUNCTION GetMenuProperty(VAR theObjToken:AEDesc; VAR dataDesc: AEDesc):OSErr;
  2347.     VAR
  2348.       theErr                   : OSErr;
  2349.         theName                  : Str255;
  2350.         theMenuPropToken    : MenuPropToken;
  2351.         newDesc           : AEDesc;
  2352.         tokenSize         : Size;
  2353.         
  2354.     BEGIN
  2355.         theErr := AECoerceDesc(theObjToken, typeMyMenuProp, newDesc);
  2356.         IF (theErr=noErr) THEN
  2357.             BEGIN
  2358.                 GetRawDataFromDescriptor(newDesc,
  2359.                                                                  Ptr(@theMenuPropToken),
  2360.                                                                  sizeof(theMenuPropToken),
  2361.                                                                  tokenSize);
  2362.                                                                  
  2363.                 theErr := AEDisposeDesc(newDesc);
  2364.             END
  2365.         ELSE
  2366.             BEGIN
  2367.                 GetMenuProperty := theErr;
  2368.                 Exit(GetMenuProperty);
  2369.             END;
  2370.  
  2371.         theErr := kAEGenericErr;
  2372.         
  2373.         IF (theMenuPropToken.theMenuProp = pName) THEN
  2374.             BEGIN
  2375.               theName := theMenuPropToken.theMenuToken.theTokenMenu^^.menuData;
  2376.                 theErr  := AECreateDesc(typeChar,
  2377.                                                               Ptr(@theName[1]),
  2378.                                                               length(theName),
  2379.                                                               dataDesc);
  2380.             END;
  2381.         
  2382.         IF (theMenuPropToken.theMenuProp = pMenuID) THEN
  2383.             BEGIN
  2384.                 theErr := AECreateDesc(typeShortInteger,
  2385.                                                              Ptr(@theMenuPropToken.theMenuToken.theTokenID),
  2386.                                                              sizeof(theMenuPropToken.theMenuToken.theTokenID),
  2387.                                                              dataDesc);
  2388.             END;
  2389.                                 
  2390.         GetMenuProperty:=theErr;
  2391.     END; (* GetMenuProperty *)
  2392.     
  2393. (** -----------------------------------------------------------------------
  2394.         Name:             GetMenuItemProperty
  2395.         Purpose:        Fills dataDesc with the requested menu property.
  2396.      -----------------------------------------------------------------------**)
  2397.      
  2398. FUNCTION GetMenuItemProperty(VAR theObjToken:AEDesc; VAR dataDesc:AEDesc):OSErr;
  2399.     VAR
  2400.       theErr               : OSErr;
  2401.         theName              : Str255;
  2402.         theMenuItemPropToken : MenuItemPropToken;
  2403.         newDesc              : AEDesc;
  2404.         tokenSize            : Size;
  2405.         
  2406.     BEGIN    
  2407.         theErr := AECoerceDesc(theObjToken, typeMyItemProp, newDesc);
  2408.         IF (theErr=noErr) THEN
  2409.             BEGIN
  2410.                 GetRawDataFromDescriptor(newDesc,
  2411.                                                                  Ptr(@theMenuItemPropToken),
  2412.                                                                  sizeof(theMenuItemPropToken),
  2413.                                                                  tokenSize);
  2414.                                                                  
  2415.                 theErr := AEDisposeDesc(newDesc);
  2416.             END
  2417.         ELSE
  2418.           BEGIN
  2419.                 GetMenuItemProperty:=theErr;
  2420.                 Exit(GetMenuItemProperty);
  2421.             END;
  2422.  
  2423.         theErr := kAEGenericErr;
  2424.         
  2425.         IF (theMenuItemPropToken.theItemProp = pName) THEN
  2426.             BEGIN
  2427.               GetItem(theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu,
  2428.                         theMenuItemPropToken.theItemToken.theTokenItem,
  2429.                                 theName);
  2430.                 theErr  := AECreateDesc(typeChar,
  2431.                                                               Ptr(@theName[1]),
  2432.                                                               length(theName),
  2433.                                                               dataDesc);
  2434.             END;
  2435.         
  2436.         IF (theMenuItemPropToken.theItemProp = pItemNumber) THEN
  2437.             BEGIN
  2438.                 theErr := AECreateDesc(typeShortInteger,
  2439.                                                              Ptr(@theMenuItemPropToken.theItemToken.theTokenItem),
  2440.                                                              sizeof(theMenuItemPropToken.theItemToken.theTokenItem),
  2441.                                                              dataDesc);
  2442.             END;
  2443.                     
  2444.         GetMenuItemProperty := theErr;
  2445.     END; (* GetMenuItemProperty *)
  2446.  
  2447. {* -----------------------------------------------------------------------
  2448.         Name:             HandleGetData
  2449.         Purpose:        Coerces theObj into a token which we understand and
  2450.                                 extracts the data requested in the token and puts it
  2451.                                 into dataDesc.
  2452.      -----------------------------------------------------------------------*}
  2453.      
  2454. FUNCTION HandleGetData(theObj: AEDesc; whatType: DescType; VAR dataDesc: AEDesc): OSErr;
  2455. VAR myErr                            : OSErr;
  2456.         newDesc                        : AEDesc;
  2457.         theTextToken      : textToken;
  2458.         tokenSize         : Size;
  2459.         theDoc                        : DPtr;
  2460.         objTokenDesc      : AEDesc;
  2461.  
  2462. BEGIN    
  2463.   myErr:= errAEWrongDataType;
  2464.     (*
  2465.         Resolve theObj into an AEDesc which will contain something we understand
  2466.         - i.e. One of our internal token types
  2467.     *)
  2468.     
  2469.     myErr:= AEResolve(theObj ,kAEIDoMinimum, objTokenDesc);
  2470.   
  2471.     IF (myErr=noErr) THEN
  2472.     
  2473.     IF (objTokenDesc.descriptorType = typeMyApplProp) THEN
  2474.         myErr := GetApplicationProperty(objTokenDesc, dataDesc)
  2475.     ELSE
  2476.     
  2477.     IF (objTokenDesc.descriptorType = typeMyMenuProp) THEN
  2478.         myErr := GetMenuProperty(objTokenDesc, dataDesc)
  2479.     ELSE
  2480.     
  2481.     IF (objTokenDesc.descriptorType = typeMyItemProp) THEN
  2482.         myErr := GetMenuItemProperty(objTokenDesc, dataDesc)
  2483.     ELSE
  2484.     
  2485.     IF (objTokenDesc.descriptorType = typeMyTextProp) THEN
  2486.         myErr := GetTextProperty(objTokenDesc, dataDesc)
  2487.     ELSE
  2488.     
  2489.     IF (objTokenDesc.descriptorType = typeMyWindowProp) THEN
  2490.         myErr := GetWindowProperty(objTokenDesc, dataDesc)
  2491.     ELSE    
  2492.         IF (objTokenDesc.descriptorType = typeMyText) THEN
  2493.             BEGIN
  2494.                 IF (AECoerceDesc(theObj,typeMyText,newDesc) = noErr) THEN
  2495.                     BEGIN
  2496.                         GetRawDataFromDescriptor(newDesc,
  2497.                                                                          @theTextToken,
  2498.                                                                          SizeOf(theTextToken),
  2499.                                                                          tokenSize);
  2500.                                                                          
  2501.                         myErr := AEDisposeDesc(newDesc);
  2502.                                                                          
  2503.                         theDoc                 := DPtrFromWindowPtr(theTextToken.tokenWindow);
  2504.                         
  2505.                         myErr := BuildStyledTextDesc( theDoc^.theText,
  2506.                                                                                     theTextToken.tokenOffset,
  2507.                                                                                     theTextToken.tokenLength,
  2508.                                                                                     dataDesc);
  2509.                     END;
  2510.             END
  2511.         ELSE
  2512.           myErr := kAEGenericErr;
  2513.         
  2514.     HandleGetData := myErr;
  2515. END;    { HandleGetData }
  2516.  
  2517. {* -----------------------------------------------------------------------
  2518.         Name:             DoGetData
  2519.         Purpose:        Handles the GetData AppleEvent.
  2520.      -----------------------------------------------------------------------*}
  2521.  
  2522. FUNCTION DoGetData(theAppleEvent    : AppleEvent;
  2523.                                      reply                    : AppleEvent;
  2524.                                      handlerRefCon    : LongInt): OSErr;
  2525. VAR 
  2526.     myErr                : OSErr;
  2527.     tempErr     : OSErr;
  2528.     myDirObj        : AEDesc;
  2529.     myDataDesc    : AEDesc;
  2530.     actualSize  : Size;
  2531.     returnedType: DescType;
  2532.     reqType     : DescType;
  2533.     
  2534. BEGIN
  2535.     myDataDesc.dataHandle := nil;
  2536.     myDirObj.dataHandle   := nil;
  2537.   
  2538.   (*
  2539.         extract the direct object, which is the object whose data is to be returned
  2540.     *)
  2541.     
  2542.   myErr := AEGetParamDesc(theAppleEvent,
  2543.                                                   keyDirectObject,
  2544.                                                     typeWildCard,
  2545.                                                     myDirObj);
  2546.       
  2547.   (*
  2548.         now the get the type of data wanted - optional
  2549.     *)
  2550.     
  2551.   tempErr := AEGetParamPtr(    theAppleEvent,
  2552.                                                         keyAERequestedType,
  2553.                                                         typeType,
  2554.                                                         returnedType,
  2555.                                                   @reqType,
  2556.                                                         SizeOf(reqType),
  2557.                                                         actualSize);
  2558.     
  2559.     IF (tempErr<>noErr) THEN
  2560.         reqType := typeChar;
  2561.       
  2562.     IF (myErr = noErr) THEN
  2563.       myErr := GotRequiredParams(theAppleEvent);
  2564.   
  2565.   { get the data }
  2566.   IF (myErr = noErr) THEN
  2567.         myErr := HandleGetData(myDirObj, reqType, myDataDesc);
  2568.         
  2569.   { if they wanted a reply, attach it now }
  2570.   IF (myErr=noErr) THEN
  2571.         IF (reply.descriptorType <> typeNull) THEN
  2572.       myErr := AEPutParamDesc(reply, keyDirectObject, myDataDesc);
  2573.  
  2574.   IF (myDataDesc.dataHandle<>NIL) THEN
  2575.         tempErr := AEDisposeDesc(myDataDesc);
  2576.         
  2577.     IF (myDirObj.dataHandle<>NIL) THEN
  2578.         tempErr := AEDisposeDesc(myDirObj);
  2579.         
  2580.   DoGetData := myErr;
  2581. END;    { DoGetData }
  2582.  
  2583.  
  2584. {* -----------------------------------------------------------------------
  2585.         Name:             DoGetDataSize
  2586.         Purpose:        Handles the GetDataSize AppleEvent.
  2587.      -----------------------------------------------------------------------*}
  2588.  
  2589. FUNCTION DoGetDataSize(theAppleEvent    : AppleEvent;
  2590.                                               reply                    : AppleEvent;
  2591.                                               handlerRefCon    : LongInt): OSErr;
  2592. VAR 
  2593.     myErr                : OSErr;
  2594.     tempErr     : OSErr;
  2595.     myDirObj        : AEDesc;
  2596.     myDataDesc    : AEDesc;
  2597.     actualSize  : Size;
  2598.     returnedType: DescType;
  2599.     reqType     : DescType;
  2600.     dataSize        : longInt;
  2601.     
  2602. BEGIN
  2603.     myDataDesc.dataHandle := nil;
  2604.     myDirObj.dataHandle   := nil;
  2605.   
  2606.   { pick up the direct object, which is the object whose data is to be sized }
  2607.     
  2608.   myErr := AEGetParamDesc(theAppleEvent,
  2609.                                                   keyDirectObject,
  2610.                                                     typeWildCard,
  2611.                                                     myDirObj);
  2612.       
  2613.   { now the get the type wanted - optional}
  2614.     
  2615.   tempErr := AEGetParamPtr(    theAppleEvent,
  2616.                                                         keyAERequestedType,
  2617.                                                         typeType,
  2618.                                                         returnedType,
  2619.                                                   @reqType,
  2620.                                                         SizeOf(reqType),
  2621.                                                         actualSize);
  2622.     
  2623.     IF (tempErr<>noErr) THEN
  2624.         reqType := typeChar;
  2625.       
  2626.     IF (myErr = noErr) THEN
  2627.       myErr := GotRequiredParams(theAppleEvent);
  2628.   
  2629.   { get the data }
  2630.   IF (myErr = noErr) THEN
  2631.         myErr := HandleGetData(myDirObj, reqType, myDataDesc);
  2632.         
  2633.     { evaluate size of data and discard, create desc for size }
  2634.     IF (myErr = noErr) THEN
  2635.         IF (myDataDesc.dataHandle<>NIL) THEN
  2636.             BEGIN
  2637.                 dataSize := GetHandleSize(Handle(myDataDesc.dataHandle));
  2638.                 DisposHandle(Handle(myDataDesc.dataHandle));
  2639.                 myErr := AECreateDesc(typeLongInteger,
  2640.                                                             @dataSize,
  2641.                                                             sizeOf(dataSize),
  2642.                                                             myDataDesc);
  2643.             END;
  2644.         
  2645.         
  2646.   { if they wanted a reply, attach it now }
  2647.     
  2648.   IF (myErr=noErr) THEN
  2649.         IF (reply.descriptorType <> typeNull) THEN
  2650.       myErr := AEPutParamDesc(reply, keyDirectObject, myDataDesc);
  2651.             
  2652.     { discard our copy }
  2653.     
  2654.     IF (myDataDesc.dataHandle<>NIL) THEN
  2655.         tempErr := AEDisposeDesc(myDataDesc);
  2656.  
  2657.     IF (myDirObj.dataHandle<>NIL) THEN
  2658.         tempErr := AEDisposeDesc(myDirObj);
  2659.             
  2660.   DoGetDataSize := myErr;
  2661. END;    { DoGetDataSize }
  2662.  
  2663. {* -----------------------------------------------------------------------
  2664.         Name:             DoNewElement
  2665.         Purpose:        Handles the NewElement AppleEvent.
  2666.      -----------------------------------------------------------------------*}
  2667.  
  2668. FUNCTION DoNewElement(theAppleEvent    : AppleEvent;
  2669.                                             reply                    : AppleEvent; 
  2670.                                             handlerRefCon    : LongInt): OSErr;
  2671.                                             
  2672. {
  2673.     Create New Windows - or error
  2674. }
  2675. VAR 
  2676.     myErr                    :    OSErr;
  2677.     ignoreErr     : OSErr;
  2678.     returnedType    :    DescType;
  2679.     newElemClass    :    DescType;
  2680.     actSize                :    Size;
  2681.     wndwObjSpec        :    AEDesc;
  2682.     theDoc        : DPtr;
  2683.     
  2684. BEGIN    
  2685.     wndwObjSpec.dataHandle := NIL;
  2686.         
  2687.     myErr := AEGetParamPtr(    theAppleEvent,
  2688.                                                     keyAEObjectClass,
  2689.                                                     typeType,
  2690.                                                     returnedType,
  2691.                                                     @newElemClass,
  2692.                                                     SizeOf(newElemClass),
  2693.                                                     actSize);
  2694.             
  2695.   { check for missing required parameters }
  2696.     
  2697.   IF (myErr = noErr) THEN
  2698.         myErr := GotRequiredParams(theAppleEvent);
  2699.   
  2700.   { got all required params }
  2701.   
  2702.   { let's make sure container is the null desc }
  2703.   { and they want a window }
  2704.     
  2705.   IF (newElemClass <> cWindow) THEN
  2706.     myErr := errAEWrongDataType;
  2707.   
  2708.   { let's create a new window }
  2709.     
  2710.     IF (myErr = noErr) THEN
  2711.         theDoc := NewDocument(FALSE);
  2712.   
  2713.     IF (myErr = noErr) THEN
  2714.         IF (theDoc = NIL) THEN
  2715.             myErr := -1700
  2716.         ELSE
  2717.             BEGIN
  2718.                 ShowWindow(theDoc^.theWindow);
  2719.                 theDoc^.dirty := FALSE;
  2720.             
  2721.                 myErr := MakeWindowObj(theDoc^.theWindow,
  2722.                                                              wndwObjSpec);
  2723.             END;
  2724.       
  2725.     IF (myErr = noErr) THEN
  2726.         IF (reply.descriptorType <> typeNull) THEN
  2727.              myErr := AEPutParamDesc(reply,
  2728.                                                              keyDirectObject,
  2729.                                                              wndwObjSpec);
  2730.             
  2731.     IF (wndwObjSpec.dataHandle<>NIL) THEN
  2732.         ignoreErr := AEDisposeDesc(wndwObjSpec);
  2733.         
  2734.   DoNewElement := myErr;
  2735. END;    { DoNewElement }
  2736.  
  2737. {* -----------------------------------------------------------------------
  2738.         Name:             DoIsThereA
  2739.         Purpose:        Handles the IsThereA AppleEvent.
  2740.      -----------------------------------------------------------------------*}
  2741.  
  2742. FUNCTION DoIsThereA(theAppleEvent    : AppleEvent;
  2743.                                         reply                    : AppleEvent; 
  2744.                                         handlerRefCon    : LongInt): OSErr;
  2745.                                             
  2746. {
  2747.     Support check of Windows at first
  2748.     
  2749.     What we do :
  2750.         Get Direct Object
  2751.         Check have all required params
  2752.         Coerce into things we support
  2753.         if we get something back
  2754.             check to see it exists and set reply
  2755.         clean up
  2756.         return
  2757. }
  2758.  
  2759. VAR 
  2760.     myErr                    :    OSErr;
  2761.   ignoreErr     : OSErr;
  2762.     myDirObject        :    AEDesc;
  2763.     windDesc      : AEDesc;
  2764.     dataDesc            :    AEDesc;
  2765.     theWindowToken: WindowToken;
  2766.     tokenSize     : Size;
  2767.     exists        : Boolean;
  2768.     
  2769. BEGIN
  2770.   myErr := noErr;
  2771.     
  2772.     myDirObject.dataHandle := NIL;
  2773.     windDesc.dataHandle    := NIL;
  2774.     dataDesc.dataHandle    := NIL;
  2775.         
  2776.     myErr := AEGetParamDesc(theAppleEvent,
  2777.                                                     keyDirectObject,
  2778.                                                     typeWildCard,
  2779.                                                     myDirObject);
  2780.                 
  2781.   { check for missing required parameters }
  2782.     
  2783.   IF (myErr = noErr) THEN
  2784.         myErr := GotRequiredParams(theAppleEvent);
  2785.   
  2786.   { got all required params }
  2787.   
  2788.   { let's make sure they want to check for a window }
  2789.         
  2790.     exists := FALSE;
  2791.     
  2792.   IF (myErr = noErr) THEN
  2793.         IF (AECoerceDesc(myDirObject,typeMyWndw,windDesc) = noErr) THEN
  2794.             IF (windDesc.descriptorType<>typeNull) THEN
  2795.                 BEGIN
  2796.                     GetRawDataFromDescriptor(windDesc,
  2797.                                                                      @theWindowToken,
  2798.                                                                      SizeOf(theWindowToken),
  2799.                                                                      tokenSize);
  2800.                                                                      
  2801.                     exists := (theWindowToken <> NIL);    
  2802.                 END;
  2803.                 
  2804.   IF (myErr = noErr) THEN
  2805.         myErr := AECreateDesc(typeBoolean,
  2806.                                                     @exists,
  2807.                                                     sizeof(exists),
  2808.                                                     dataDesc);
  2809.  
  2810.       
  2811.   { 
  2812.         if they wanted a reply, which they surely must, 
  2813.       attach the result to it…
  2814.     }
  2815.         
  2816.     IF (myErr = noErr) THEN
  2817.         IF (reply.descriptorType <> typeNull) THEN
  2818.              myErr := AEPutParamDesc(reply,
  2819.                                                              keyDirectObject,
  2820.                                                              dataDesc);
  2821.             
  2822.     IF (dataDesc.dataHandle<>NIL) THEN
  2823.         ignoreErr := AEDisposeDesc(dataDesc);
  2824.         
  2825.     IF (myDirObject.dataHandle<>NIL) THEN
  2826.         ignoreErr := AEDisposeDesc(myDirObject);
  2827.         
  2828.     IF (windDesc.dataHandle<>NIL) THEN
  2829.         ignoreErr := AEDisposeDesc(windDesc);
  2830.         
  2831.   DoIsThereA := myErr;
  2832. END;    { DoIsThereA }
  2833.  
  2834. {* -----------------------------------------------------------------------
  2835.         Name:             DoCloseWindow
  2836.         Purpose:        Handles the Close AppleEvent.
  2837.      -----------------------------------------------------------------------*}
  2838.  
  2839. FUNCTION DoCloseWindow(    theAppleEvent    : AppleEvent;
  2840.                                                  reply                    : AppleEvent;
  2841.                                                  handlerRefCon    : LongInt): OSErr;
  2842. VAR 
  2843.     myErr                        : OSErr;
  2844.     tempErr             : OSErr;
  2845.     myDirObj                : AEDesc;
  2846.     newDesc             : AEDesc;
  2847.     theWindowToken    : windowToken;
  2848.     tokenSize                 : Size;
  2849.     saveOpt                    : DescType;
  2850.     actSize                    : Size;
  2851.     returnedType        : DescType;
  2852.     theDoc          : DPtr;
  2853.     
  2854. BEGIN
  2855.   myDirObj.dataHandle := nil;
  2856.     
  2857.   { pick up the direct object, which is the object (window) to close }
  2858.     
  2859.   myErr := AEGetParamDesc(theAppleEvent,
  2860.                                                   keyDirectObject,
  2861.                                                     typeWildCard,
  2862.                                                     myDirObj);
  2863.             
  2864.     { pick up optional save param, if any }
  2865.     
  2866.   saveOpt := kAEAsk; { the default }
  2867.     
  2868.   tempErr := AEGetParamPtr(theAppleEvent,
  2869.                                                      keyAESaveOptions,
  2870.                                                      typeEnumerated,
  2871.                                                      returnedType,
  2872.                                                @saveOpt,
  2873.                                                      SizeOf(saveOpt),
  2874.                                                      actSize);
  2875.     IF (myErr = noErr) THEN
  2876.       myErr := GotRequiredParams(theAppleEvent);
  2877.         
  2878.   { get the window to close as a window ptr }
  2879.   IF (myErr = noErr) THEN
  2880.         IF (AECoerceDesc(myDirObj,typeMyWndw,newDesc) = noErr) THEN
  2881.             IF (newDesc.descriptorType<>typeNull) THEN
  2882.                 BEGIN
  2883.                     GetRawDataFromDescriptor(newDesc,
  2884.                                                                      @theWindowToken,
  2885.                                                                      SizeOf(theWindowToken),
  2886.                                                                      tokenSize);
  2887.                                                                      
  2888.                     myErr := AEDisposeDesc(newDesc);
  2889.                     
  2890.                     IF (theWindowToken<>NIL) THEN
  2891.                         BEGIN
  2892.                             myErr:=AESetInteractionAllowed(kAEInteractWithAll); (* Should do this in prefs *)
  2893.                             
  2894.                             (*
  2895.                                 We do some of the close checks here to avoid
  2896.                                 calling AEInteractWithUser
  2897.                             *)
  2898.                             theDoc := DPtrFromWindowPtr(theWindowToken);
  2899.                             
  2900.                             IF (theDoc^.dirty) OR
  2901.                                  (theDoc^.everSaved=false) THEN
  2902.                                 IF (saveOpt <> kAENo) THEN
  2903.                                     BEGIN
  2904.                                         myErr := AEInteractWithUser(kAEDefaultTimeOut,
  2905.                                                                                                 NIL,
  2906.                                                                                                 NIL);
  2907.                                     END;
  2908.                                 
  2909.                             IF myErr=noErr THEN
  2910.                                 myErr := DoClose(theWindowToken, TRUE, saveOpt);
  2911.                         END
  2912.                     ELSE
  2913.                         myErr:=  errAEIllegalIndex;
  2914.                 END;
  2915.                     
  2916.     IF (myDirObj.dataHandle<>NIL) THEN
  2917.         myErr := AEDisposeDesc(myDirObj);
  2918.             
  2919.   DoCloseWindow := myErr;
  2920. END;    { DoCloseWindow }
  2921.  
  2922. {* -----------------------------------------------------------------------
  2923.         Name:             DoSaveWindow
  2924.         Purpose:        Handles the Save AppleEvent.
  2925.      -----------------------------------------------------------------------*}
  2926.  
  2927. FUNCTION DoSaveWindow(theAppleEvent    : AppleEvent;
  2928.                                              reply                    : AppleEvent;
  2929.                                              handlerRefCon    : LongInt): OSErr;
  2930. VAR 
  2931.     myErr                        : OSErr;
  2932.     tempErr             : OSErr;
  2933.     myDirObj                : AEDesc;
  2934.     newDesc             : AEDesc;
  2935.     theWindowToken    : windowToken;
  2936.     tokenSize                 : Size;
  2937.     actSize                    : Size;
  2938.     returnedType        : DescType;
  2939.     theDoc                    : DPtr;
  2940.     destFSSpec            : FSSpec;
  2941.     
  2942. BEGIN    
  2943.     myDirObj.dataHandle := NIL;
  2944.     
  2945.   { pick up the direct object, which is the window to save }
  2946.     
  2947.   myErr := AEGetParamDesc(theAppleEvent,
  2948.                                                   keyDirectObject,
  2949.                                                     typeWildCard,
  2950.                                                     myDirObj);
  2951.     { pick up optional destination param, if any }
  2952.  
  2953.   tempErr := AEGetParamPtr(theAppleEvent,
  2954.                                                      keyAEDestination,
  2955.                                                      typeFSS,
  2956.                                                      returnedType,
  2957.                                                @destFSSpec,
  2958.                                                      SizeOf(destFSSpec),
  2959.                                                      actSize);
  2960.  
  2961.     IF (myErr = noErr) THEN
  2962.       myErr := GotRequiredParams(theAppleEvent);
  2963.         
  2964.   { get the data }
  2965.  
  2966.     myErr := AECoerceDesc(myDirObj,typeMyWndw,newDesc);
  2967.     
  2968.   IF (myErr = noErr) THEN
  2969.         IF (newDesc.descriptorType<>typeNull) THEN
  2970.             BEGIN
  2971.                 GetRawDataFromDescriptor(newDesc,
  2972.                                                                  @theWindowToken,
  2973.                                                                  SizeOf(theWindowToken),
  2974.                                                                  tokenSize);
  2975.                                                                  
  2976.                 myErr := AEDisposeDesc(newDesc);
  2977.                                                                  
  2978.                 IF (theWindowToken<>NIL) THEN
  2979.                     BEGIN                            
  2980.                         theDoc := DPtrFromWindowPtr(theWindowToken);
  2981.                         
  2982.                         IF (theDoc^.everSaved = false) THEN
  2983.                             IF (tempErr<>noErr) THEN
  2984.                                 (* We had no supplied destination and no default either *)
  2985.                                 myErr := kAEGenericErr;
  2986.                         
  2987.                         IF (myErr=noErr) THEN
  2988.                             IF (tempErr=noErr) THEN
  2989.                                 BEGIN (* we were told where *)
  2990.                                     myErr := DoSave(theDoc, destFSSpec);
  2991.                                     
  2992.                                     IF (myErr=noErr) THEN                                        
  2993.                                         AssocAllSections(theDoc);
  2994.                                 END
  2995.                             ELSE
  2996.                                 myErr := SaveUsingTemp(theDoc);
  2997.                     END
  2998.                 ELSE
  2999.                     myErr:=  errAEIllegalIndex;
  3000.             END;
  3001.             
  3002.   DoSaveWindow := myErr;
  3003.     
  3004.     IF (myDirObj.dataHandle<>NIL) THEN
  3005.         myErr := AEDisposeDesc(myDirObj);
  3006.         
  3007. END;    { DoSaveWindow }
  3008.  
  3009. {* -----------------------------------------------------------------------
  3010.         Name:             DoRevertWindow
  3011.         Purpose:        Handles the Revert AppleEvent.
  3012.      -----------------------------------------------------------------------*}
  3013.  
  3014. FUNCTION DoRevertWindow(theAppleEvent    : AppleEvent;
  3015.                                                  reply                    : AppleEvent;
  3016.                                                  handlerRefCon    : LongInt): OSErr;
  3017. VAR 
  3018.     myErr                        : OSErr;
  3019.     ignoreErr             : OSErr;
  3020.     myDirObj                : AEDesc;
  3021.     newDesc             : AEDesc;
  3022.     theWindowToken    : windowToken;
  3023.     tokenSize                 : Size;
  3024.     theDoc                    : DPtr;
  3025.     
  3026. BEGIN    
  3027.     myDirObj.dataHandle := NIL;
  3028.     
  3029.   { pick up the direct object, which is the window to save }
  3030.     
  3031.   myErr := AEGetParamDesc(theAppleEvent,
  3032.                                                   keyDirectObject,
  3033.                                                     typeWildCard,
  3034.                                                     myDirObj);
  3035.  
  3036.     IF (myErr = noErr) THEN
  3037.       myErr := GotRequiredParams(theAppleEvent);
  3038.         
  3039.   { get the window to revert from the direct object }
  3040.     
  3041.     myErr := AECoerceDesc(myDirObj,typeMyWndw,newDesc);
  3042.     
  3043.   IF (myErr = noErr) THEN
  3044.         IF (newDesc.descriptorType<>typeNull) THEN
  3045.             BEGIN
  3046.                 GetRawDataFromDescriptor(newDesc,
  3047.                                                                  @theWindowToken,
  3048.                                                                  SizeOf(theWindowToken),
  3049.                                                                  tokenSize);
  3050.                                                                  
  3051.                 myErr := AEDisposeDesc(newDesc);
  3052.                                                                  
  3053.                 IF (theWindowToken<>NIL) THEN
  3054.                     BEGIN                            
  3055.                         theDoc := DPtrFromWindowPtr(theWindowToken);
  3056.                         
  3057.                         HidePen;
  3058.                         TESetSelect(0, theDoc^.theText^^.teLength, theDoc^.theText);
  3059.                         ShowPen;
  3060.                         TEDelete(theDoc^.theText);
  3061.         
  3062.                         IF (theDoc^.everSaved) THEN
  3063.                             BEGIN
  3064.                                 myErr := GetFileContents(theDoc^.theFSSpec, theDoc);
  3065.                                 IF (myErr = noErr) THEN
  3066.                                     BEGIN
  3067.                                         ResizeWindow(theDoc);
  3068.                                         theDoc^.dirty := FALSE;
  3069.                                     END;
  3070.                             END;
  3071.         
  3072.                         ShowWindow(theDoc^.theWindow); (* <<< Visible already??? *)
  3073.                         DoUpdate(theDoc);
  3074.                     END
  3075.                 ELSE
  3076.                     myErr:=  errAEIllegalIndex;
  3077.             END;
  3078.  
  3079.     IF (myDirObj.dataHandle<>NIL) THEN
  3080.         ignoreErr := AEDisposeDesc(myDirObj);
  3081.             
  3082.   DoRevertWindow := myErr;
  3083. END;    { DoRevertWindow }
  3084.  
  3085. {*-----------------------------------------------------------------------
  3086.         Name:             DoPrintDocuments
  3087.         Purpose:        Print a list of documents (or windows).
  3088. -----------------------------------------------------------------------*}
  3089. FUNCTION DoPrintDocuments( message, reply: AppleEvent; refcon: LONGINT ): OSErr;
  3090. VAR
  3091.         index                        : LONGINT;
  3092.         itemsInList         : LONGINT;
  3093.         keywd                     : AEKeyWord;
  3094.         err                         : OSErr;
  3095.         docList                 : AEDescList;
  3096.         actSize                 : Size;
  3097.         typeCode                : DescType;
  3098.         theFSSpec             : FSSpec;
  3099.         theWindowToken     : WindowToken;
  3100.         forgetErr           : OSErr;
  3101.         talkToUser      : Boolean;
  3102.         
  3103. BEGIN    
  3104.     err := AEGetParamDesc(message, keyDirectObject, typeAEList, docList) ;
  3105.     err := AECountItems( docList, itemsInList) ;
  3106.         
  3107.     FOR index := 1 TO itemsInList DO
  3108.         IF (err = noErr) THEN
  3109.             BEGIN
  3110.                 forgetErr := AEGetNthPtr( docList, index, typeFSS, keywd, typeCode,
  3111.                                                     @theFSSpec, sizeof(theFSSpec), actSize);
  3112.                                                                     
  3113.                 IF (forgetErr = noErr) THEN
  3114.                     BEGIN
  3115.                         IF (err = noErr) THEN
  3116.                             err := IssueAEOpenDoc(theFSSpec);
  3117.                             
  3118.                         IF (err = noErr) THEN
  3119.                             IssuePrintWindow(FrontWindow);
  3120.                             
  3121.                         IF (err = noErr) THEN
  3122.                             IssueCloseCommand(FrontWindow);
  3123.                     END
  3124.                 ELSE
  3125.                     BEGIN (* wasn't a file - was it a window ? *)
  3126.                         err := AEGetNthPtr( docList, index, typeMyWndw, keywd, typeCode,
  3127.                                                   @theWindowToken, sizeof(windowToken), actSize);
  3128.                                                                 
  3129.                         talkToUser := (AEInteractWithUser(kAEDefaultTimeOut, NIL, NIL) = noErr);
  3130.                         
  3131.                         IF (err = noErr) THEN
  3132.                             PrintWindow(DPtrFromWindowPtr(theWindowToken), talkToUser);
  3133.                     END
  3134.             END;
  3135.         
  3136.     IF (docList.dataHandle<>NIL) THEN
  3137.       forgetErr := AEDisposeDesc(docList);
  3138.         
  3139.     DoPrintDocuments := err;
  3140. END; (* DoPrintDocuments *)
  3141.  
  3142. {*-----------------------------------------------------------------------
  3143.         Name:             HandleCreatePub
  3144.         Purpose:        Create a publisher.
  3145. -----------------------------------------------------------------------*}
  3146. FUNCTION HandleCreatePub( theAppleEvent, reply: AppleEvent; refcon: LONGINT ): OSErr;
  3147. VAR
  3148.         myErr                     : OSErr;
  3149.         theFSSpec             : FSSpec;
  3150.         forgetErr           : OsErr;
  3151.         forget2Err           : OsErr;
  3152.         myDirObj                : AEDesc;
  3153.         myFileLoc                : AEDesc;
  3154.         theTextToken       : TextToken;
  3155.         theDoc          : DPtr;
  3156.         newDesc                    : AEDesc;
  3157.         tokenSize                : LongInt;
  3158.         haveFSSpec            : BOOLEAN;
  3159.         
  3160. BEGIN
  3161.     myErr := noErr;
  3162.     
  3163.   forgetErr  := AEGetParamDesc(theAppleEvent,
  3164.                                                              keyDirectObject,
  3165.                                                              typeWildCard,
  3166.                                                              myDirObj);
  3167.     
  3168.     forget2Err := AEGetParamDesc(theAppleEvent,
  3169.                                                              keyAEEditionFileLoc,
  3170.                                                              typeWildCard,
  3171.                                                              myFileLoc);
  3172.                                                              
  3173.     IF (myErr=noErr) THEN
  3174.         myErr := GotRequiredParams(theAppleEvent);
  3175.         
  3176.     IF (forgetErr=noErr) THEN (* Set the selection to the supplied object - if any *)
  3177.         BEGIN
  3178.             forgetErr := AECoerceDesc(myDirObj,typeMyText,newDesc);
  3179.             IF (newDesc.descriptorType<>typeNull) THEN
  3180.                 BEGIN
  3181.                     GetRawDataFromDescriptor(newDesc,
  3182.                                                                      @theTextToken,
  3183.                                                                      SizeOf(theTextToken),
  3184.                                                                      tokenSize);
  3185.                                                                      
  3186.                     theDoc                 := DPtrFromWindowPtr(theTextToken.tokenWindow);
  3187.                     
  3188.                     TESetSelect(theTextToken.tokenOffset-1,
  3189.                                           theTextToken.tokenOffset+
  3190.                                                                 theTextToken.tokenLength-1,
  3191.                                           theDoc^.theText);
  3192.                                             
  3193.                     forgetErr := AEDisposeDesc(newDesc);
  3194.                 END;
  3195.         END
  3196.     ELSE
  3197.         theDoc := DPtrFromWindowPtr(FrontWindow);
  3198.         
  3199.     IF (theDoc=NIL) THEN
  3200.         BEGIN
  3201.             (* Should clean up and exit with error *)
  3202.         END;
  3203.         
  3204.     haveFSSpec := FALSE;
  3205.     
  3206.     IF (forget2Err=noErr) THEN (* Get the Edition Container File *)
  3207.         BEGIN
  3208.             forget2Err := AECoerceDesc(myDirObj,typeFSS,newDesc);
  3209.             IF (newDesc.descriptorType<>typeNull) THEN
  3210.                 BEGIN
  3211.                     GetRawDataFromDescriptor(newDesc,
  3212.                                                                      @theFSSpec,
  3213.                                                                      SizeOf(theFSSpec),
  3214.                                                                      tokenSize);
  3215.                     forget2Err := AEDisposeDesc(newDesc);
  3216.                     haveFSSpec := TRUE;
  3217.                 END;
  3218.         END;
  3219.         
  3220.     IF (NOT haveFSSpec) THEN
  3221.         myErr := GetEditionContainer(theDoc, theFSSpec);
  3222.  
  3223.     IF (myErr = noErr) THEN
  3224.         myErr := PublishText(theDoc, @theFSSpec);
  3225.         
  3226.     IF (myDirObj.dataHandle<>NIL) THEN
  3227.         forgetErr := AEDisposeDesc(myDirObj);
  3228.     
  3229.     IF (myFileLoc.dataHandle<>NIL) THEN
  3230.         forgetErr := AEDisposeDesc(myFileLoc);
  3231.     
  3232.     HandleCreatePub := myErr;
  3233.     
  3234. END; (* HandleCreatePub *)
  3235.  
  3236.  
  3237. FUNCTION MyCountProc(    desiredType        : DescType;
  3238.                                             containerClass: DescType;
  3239.                                             container            : AEDesc;
  3240.                                             VAR result        : LongInt): OSErr; FORWARD;
  3241.                                             
  3242. {* -----------------------------------------------------------------------
  3243.         Name:             HandleNumberOfElements
  3244.         Purpose:        Handles the Number Of Elements AppleEvent.
  3245.      -----------------------------------------------------------------------*}
  3246.  
  3247. FUNCTION HandleNumberOfElements(theAppleEvent    : AppleEvent;
  3248.                                                                 reply                    : AppleEvent;
  3249.                                                                 handlerRefCon    : LongInt): OSErr;
  3250. VAR myErr                    :    OSErr;
  3251.         myDirObj            :    AEDesc;
  3252.         myClass                :    DescType;
  3253.         myCount                :    LongInt;
  3254.         returnedType     : DescType;
  3255.         actSize                : Size;
  3256.         
  3257. BEGIN
  3258.   myErr      := errAEEventNotHandled;
  3259.   myDirObj.dataHandle := NIL;
  3260.   
  3261.   { pick up direct object, which is the container in which things are to be counted }
  3262.   
  3263.     myErr := AEGetParamDesc(theAppleEvent,
  3264.                                                     keyDirectObject,
  3265.                                                     typeWildCard,
  3266.                                                     myDirObj);
  3267.       
  3268.   { now the class of objects to be counted }
  3269.     
  3270.   myErr := AEGetParamPtr(theAppleEvent,
  3271.                                                  keyAEObjectClass,
  3272.                                                  typeType,
  3273.                                                  returnedType,
  3274.                                                  @myClass,
  3275.                                                  SizeOf(myClass),
  3276.                                                  actSize);
  3277.       
  3278.   { missing any parameters? }
  3279.     
  3280.   myErr := GotRequiredParams(theAppleEvent);
  3281.   
  3282.   { now count }
  3283.  
  3284.     IF (myErr = noErr) THEN
  3285.         myErr := MyCountProc(myClass,myDirObj.descriptorType,myDirObj,myCount);
  3286.   
  3287.   { add result to reply }
  3288.  
  3289.     IF (myErr = noErr) THEN
  3290.         IF reply.descriptorType <> typeNull THEN 
  3291.              myErr := AEPutParamPtr(reply,
  3292.                                                             keyDirectObject,
  3293.                                                             typeLongInteger,
  3294.                                                             @myCount,
  3295.                                                             SizeOf(myCount));
  3296.     IF (myErr = noErr) THEN      
  3297.       myErr := AEDisposeDesc(myDirObj);
  3298.   
  3299.   HandleNumberOfElements := myErr;
  3300.     
  3301. END;    { HandleNumberOfElements }
  3302.  
  3303. {* -----------------------------------------------------------------------
  3304.         Name:             HandleShowSelection
  3305.         Purpose:        Handles the Make Selection Visible AppleEvent.
  3306.      -----------------------------------------------------------------------*}
  3307.  
  3308. FUNCTION HandleShowSelection(theAppleEvent    : AppleEvent;
  3309.                                                          reply                    : AppleEvent;
  3310.                                                          handlerRefCon    : LongInt): OSErr;
  3311. VAR myErr                    :    OSErr;
  3312.     ignoreErr     : OSErr;
  3313.         myDirObj            :    AEDesc;
  3314.         newDesc                :    AEDesc;
  3315.         tokenDesc     : AEDesc;
  3316.         actSize                : Size;
  3317.         theWindowToken: WindowToken;
  3318.         theDocument   : DPtr;
  3319.         theHTE        : TEHandle;
  3320.         
  3321. BEGIN
  3322.     myDirObj.dataHandle  := NIL;
  3323.   tokenDesc.dataHandle := NIL;
  3324.   
  3325.   (*
  3326.         pick up direct object, i.e. the window in which to show the selection
  3327.     *)
  3328.         
  3329.     myErr := AEGetParamDesc(theAppleEvent,
  3330.                                                     keyDirectObject,
  3331.                                                     typeWildCard,
  3332.                                                     myDirObj);
  3333.            
  3334.   (*
  3335.         missing any parameters?
  3336.     *)
  3337.     
  3338.   myErr := GotRequiredParams(theAppleEvent);
  3339.   
  3340.   (*
  3341.         convert object to windowToken which we understand
  3342.     *)
  3343.     
  3344.     myErr := AEResolve(myDirObj, kAEIDoMinimum, tokenDesc);
  3345.     
  3346.   IF (myErr = noErr) THEN
  3347.       IF (tokenDesc.descriptorType=typeMyWndw) THEN
  3348.             BEGIN
  3349.                 IF (AECoerceDesc(myDirObj,typeMyWndw,newDesc) = noErr) THEN
  3350.                     BEGIN
  3351.                         GetRawDataFromDescriptor(newDesc,
  3352.                                                                          @theWindowToken,
  3353.                                                                          SizeOf(theWindowToken),
  3354.                                                                          actSize);
  3355.                                                                          
  3356.                         IF (newDesc.dataHandle<>NIL) THEN
  3357.                             myErr := AEDisposeDesc(newDesc);
  3358.                         
  3359.                         IF (myErr=noErr) THEN
  3360.                             IF (theWindowToken<>NIL) THEN                                                         
  3361.                                 ShowSelect(DPtrFromWindowPtr(theWindowToken))
  3362.                             ELSE
  3363.                                 myErr := errAEIllegalIndex;
  3364.                             
  3365.                     END;
  3366.             END
  3367.         ELSE
  3368.             IF (tokenDesc.descriptorType=typeMyText) THEN
  3369.                 BEGIN
  3370.           myErr := SetSelectionOfAppleEventObject(keyDirectObject,
  3371.                                                                                           theAppleEvent,
  3372.                                                                                            theDocument,
  3373.                                                                                           theHTE);
  3374.                     IF (theDocument<>NIL) THEN                                                         
  3375.                         ShowSelect(theDocument)
  3376.                     ELSE
  3377.                         myErr := errAEIllegalIndex;
  3378.                 END
  3379.             ELSE
  3380.                 myErr      := errAEEventNotHandled;
  3381.   
  3382.     IF (myDirObj.dataHandle<>NIL) THEN
  3383.         ignoreErr := AEDisposeDesc(myDirObj);
  3384.         
  3385.     IF (tokenDesc.dataHandle<>NIL) THEN
  3386.         ignoreErr := AEDisposeDesc(tokenDesc);
  3387.         
  3388.   HandleShowSelection := myErr;
  3389.     
  3390. END;    { HandleShowSelection }
  3391.  
  3392. FUNCTION HandleStartRecording(theAppleEvent    : AppleEvent;
  3393.                                                           reply                    : AppleEvent;
  3394.                                                           handlerRefCon    : LongInt): OSErr;        
  3395. VAR myErr : OSErr;
  3396.  
  3397. BEGIN
  3398.   gBigBrother := gBigBrother +1;
  3399.     
  3400.     myErr := GotRequiredParams(theAppleEvent);
  3401.  
  3402.   HandleStartRecording := noErr;
  3403. END;    { HandleStartRecording }
  3404.  
  3405. FUNCTION HandleStopRecording( theAppleEvent    : AppleEvent;
  3406.                                                           reply                    : AppleEvent;
  3407.                                                           handlerRefCon    : LongInt): OSErr;        
  3408. BEGIN
  3409.   gBigBrother := gBigBrother -1;
  3410.   HandleStopRecording := noErr;
  3411. END;    { HandleStopRecording }
  3412.  
  3413. {$AECommandIssuers}
  3414.  
  3415. {*****************************************************************************}
  3416. { 
  3417.         Start of section involved in building and sending AppleEvent Objects as/with
  3418.         commands
  3419.  }
  3420.  
  3421. (*
  3422.     Make an AEDesc that describes the selection in the window and text edit
  3423.     record supplied
  3424. *)
  3425.  
  3426. FUNCTION MakeWindowObj( theWindow  : WindowPtr;
  3427.                                                 VAR dMyDoc : AEDesc):OSErr;
  3428.     VAR dNull           :    AEDesc;
  3429.             dDocName        :    AEDesc;
  3430.             windowName    : Str255;
  3431.             myErr       : OSErr;
  3432.             
  3433.     BEGIN
  3434.         GetWTitle(theWindow,windowName);
  3435.         myErr := AECreateDesc(typeChar,Pointer(ORD4(@windowName)+1), length(windowName), dDocName);
  3436.         
  3437.         if (myErr=noErr) THEN
  3438.             myErr := AECreateDesc(typeNull, nil , 0, dNull);
  3439.         
  3440.         if (myErr=noErr) THEN
  3441.             myErr := CreateObjSpecifier(cWindow, dNull, formName, dDocName, TRUE, dMyDoc);
  3442.         
  3443.         MakeWindowObj:= myErr;
  3444.         
  3445.     END; (*MakeWindowObj*)
  3446.     
  3447. FUNCTION MakeTextObj( theWindow         : WindowPtr;
  3448.                                             selStart          : INTEGER; 
  3449.                                             selEnd            : INTEGER; 
  3450.                                             VAR selTextObj    : AEDesc): OSErr;
  3451. VAR 
  3452.     myErr            : OSErr;
  3453.     ignoreErr    : OSErr;
  3454.     dMyDoc    : AEDesc;
  3455.     startOfs    :    AEDesc;
  3456.     endOfs        : AEDesc;
  3457.     startObj    :    AEDesc;
  3458.     endObj        : AEDesc;
  3459.     rangeDesc    : AEDesc;
  3460.     startChar    :    LongInt;
  3461.     endChar        :    LongInt;
  3462.     spotFlag    :    BOOLEAN;
  3463.         
  3464. BEGIN
  3465.   myErr := noErr;
  3466.     
  3467.     IF (theWindow=nil) THEN
  3468.         BEGIN
  3469.             MakeTextObj:=noErr;
  3470.             Exit(MakeTextObj);
  3471.         END;
  3472.         
  3473.     selTextObj.dataHandle := nil;
  3474.     dMyDoc.dataHandle     := nil;
  3475.     startObj.dataHandle   := nil;
  3476.     endObj.dataHandle     := nil;
  3477.     
  3478.   (* 
  3479.         make the window object 
  3480.     *)
  3481.     
  3482.     myErr := MakeWindowObj(theWindow, dMyDoc);
  3483.         
  3484.   IF (myErr=noErr) THEN
  3485.         BEGIN
  3486.             { get the start and end of selection }
  3487.             
  3488.             startChar := selStart+1;    { start counting obj's from 1, not 0 }
  3489.             endChar   := selEnd;
  3490.             spotFlag  := (selStart = selEnd);
  3491.                 
  3492.             myErr := CreateOffsetDescriptor(startChar, startOfs);
  3493.                         
  3494.             IF myErr=noErr THEN
  3495.                 IF spotFlag THEN
  3496.                     myErr := CreateObjSpecifier( cSpot,
  3497.                                                                              dMyDoc,
  3498.                                                                              formAbsolutePosition, 
  3499.                                                                              startOfs, 
  3500.                                                                              TRUE, 
  3501.                                                                              selTextObj)
  3502.                 ELSE
  3503.                     BEGIN
  3504.                         { not a spot - must represent as range }
  3505.                         { make obj for start char }
  3506.                         myErr := CreateObjSpecifier(cChar, dMyDoc, formAbsolutePosition, startOfs, FALSE, startObj);
  3507.                         
  3508.                         IF (myErr=noErr) THEN
  3509.                             myErr := CreateOffsetDescriptor(endChar, endOfs);
  3510.                         
  3511.                         IF (myErr=noErr) THEN
  3512.                             myErr := CreateObjSpecifier(cChar, dMyDoc, formAbsolutePosition, endOfs, FALSE, endObj);
  3513.                         
  3514.                         IF (myErr=noErr) THEN
  3515.                             myErr := CreateRangeDescriptor(startObj,
  3516.                                                                                         endObj,
  3517.                                                                                         FALSE,
  3518.                                                                                         rangeDesc);
  3519.                         
  3520.                         if (myErr=noErr) then
  3521.                             BEGIN
  3522.                                 myErr := CreateObjSpecifier(cChar,
  3523.                                                                                         dMyDoc,
  3524.                                                                                         formRange,
  3525.                                                                                         rangeDesc,
  3526.                                                                                         TRUE,
  3527.                                                                                         selTextObj);
  3528.                             
  3529.                             END;
  3530.                             
  3531.                         IF (startObj.dataHandle<>NIL) THEN
  3532.                             myErr := AEDisposeDesc(startObj);
  3533.                             
  3534.                         IF (endObj.dataHandle<>NIL) THEN
  3535.                             myErr := AEDisposeDesc(endObj);
  3536.                             
  3537.                         IF (startOfs.dataHandle<>NIL) THEN
  3538.                             myErr := AEDisposeDesc(startOfs);
  3539.                             
  3540.                         IF (endOfs.dataHandle<>NIL) THEN
  3541.                             myErr := AEDisposeDesc(endOfs);
  3542.                     END;
  3543.          END;
  3544.       
  3545.   MakeTextObj := myErr;
  3546. END;    { MakeTextObj }
  3547.  
  3548. FUNCTION MakeSelectedTextObj(theWindow               : WindowPtr;
  3549.                                                          theTextEditHandle : TEHandle;
  3550.                                                          VAR selTextObj    : AEDesc) : OSErr;
  3551.     BEGIN
  3552.         MakeSelectedTextObj:=  MakeTextObj(theWindow,
  3553.                                                                              theTextEditHandle^^.selStart,
  3554.                                                                              theTextEditHandle^^.selEnd,
  3555.                                                                              selTextObj);
  3556.                                                 
  3557.     END;    (* MakeSelectedTextObj *)
  3558.  
  3559. TYPE editCommandType = (editCutCommand, editCopyCommand, editPasteCommand, editClearCommand);
  3560.  
  3561. PROCEDURE DoEditCommand(theDocument:DPtr; whatCommand : editCommandType);
  3562. VAR err                          : OSErr;
  3563.         forgetErr                 : OSErr;
  3564.         ourAddress             : AEAddressDesc;
  3565.         editCommandEvent : AppleEvent;
  3566.         ignoreReply          : AppleEvent;
  3567.         ourTextSelObj    : AEDesc;
  3568.         theEventID             : AEEventID;
  3569.         theEventClass    : AEEventClass;
  3570.  
  3571.     BEGIN
  3572.         (*
  3573.                 Initialise
  3574.         *)
  3575.         ourAddress.dataHandle             := nil;
  3576.         ourTextSelObj.dataHandle         := nil;
  3577.         editCommandEvent.dataHandle := nil;
  3578.         ignoreReply.dataHandle             := nil;
  3579.         
  3580.         err := MakeSelfAddress(ourAddress);
  3581.         
  3582.         (*
  3583.             Build an object to represent the current document's selection
  3584.         *)
  3585.         err := MakeSelectedTextObj(theDocument^.theWindow, theDocument^.theText,ourTextSelObj);
  3586.         
  3587.         IF (err=noErr) THEN
  3588.             BEGIN
  3589.                 CASE whatCommand OF
  3590.                     editCutCommand     : BEGIN
  3591.                                                             theEventID    := kAECut;
  3592.                                                             theEventClass := kAEMiscStandards;
  3593.                                                         END;
  3594.                     editCopyCommand    : BEGIN
  3595.                                                             theEventID    := kAECopy;
  3596.                                                             theEventClass := kAEMiscStandards;
  3597.                                                         END;
  3598.                     editPasteCommand: BEGIN
  3599.                                                             theEventID    := kAEPaste;
  3600.                                                             theEventClass := kAEMiscStandards;
  3601.                                                         END;
  3602.                     editClearCommand: BEGIN
  3603.                                                             theEventID    := kAEDelete;
  3604.                                                             theEventClass := kAECoreSuite;
  3605.                                                         END;
  3606.                 END;
  3607.                 
  3608.                 err := AECreateAppleEvent( theEventClass, theEventID, ourAddress, 0, 0, editCommandEvent);
  3609.               
  3610.                 { add parameter }    
  3611.                 IF (err=noErr) THEN
  3612.                     err := AEPutParamDesc(editCommandEvent,keyDirectObject,ourTextSelObj);
  3613.                     
  3614.                 {and now Send the message}
  3615.                 IF (err=noErr) THEN
  3616.                     err := AESend(editCommandEvent,ignoreReply,kAENoReply,KAEHighPriority,10000,nil, nil);
  3617.             END;
  3618.             
  3619.         (*
  3620.             Clean up
  3621.         *)
  3622.         if (ourAddress.dataHandle<>nil) then
  3623.             err := AEDisposeDesc(ourAddress);
  3624.         
  3625.         if (editCommandEvent.dataHandle<>nil) then
  3626.             err := AEDisposeDesc(editCommandEvent);
  3627.         
  3628.         if (ignoreReply.dataHandle<>nil) then
  3629.             err := AEDisposeDesc(ignoreReply);
  3630.             
  3631.         if (ourTextSelObj.dataHandle<>nil) then
  3632.             err := AEDisposeDesc(ourTextSelObj);
  3633.             
  3634.     END; (*DoEditCommand*)
  3635.     
  3636. PROCEDURE IssueCutCommand(theDocument:DPtr);
  3637.     BEGIN            
  3638.         DoEditCommand(theDocument, editCutCommand);
  3639.     END;
  3640.     
  3641. PROCEDURE IssueCopyCommand(theDocument:DPtr);
  3642.     BEGIN
  3643.         DoEditCommand(theDocument, editCopyCommand);
  3644.     END;
  3645.     
  3646. PROCEDURE IssuePasteCommand(theDocument:DPtr);
  3647.     BEGIN
  3648.         DoEditCommand(theDocument, editPasteCommand);    
  3649.     END;
  3650.     
  3651. PROCEDURE IssueClearCommand(theDocument:DPtr);
  3652.     BEGIN
  3653.         DoEditCommand(theDocument, editClearCommand);    
  3654.     END;
  3655.     
  3656. PROCEDURE IssueFontCommand(theDocument:DPtr;theItem:INTEGER);
  3657.     VAR name         : Str255;
  3658.             strDesc      : AEDesc;
  3659.             theAddress : AEAddressDesc;
  3660.             selTextObj : AEDesc;
  3661.             err                 : OSErr;
  3662.             
  3663.     BEGIN
  3664.         err := MakeSelfAddress(theAddress);
  3665.         
  3666.         err := MakeSelectedTextObj(theDocument^.theWindow, theDocument^.theText, selTextObj);
  3667.         
  3668.         GetItem(myMenus[fontM], theItem, name);
  3669.         
  3670.         IF (err=noErr) THEN
  3671.             err := AECreateDesc(typeChar,
  3672.                                                     POINTER(ORD4(@name)+1),
  3673.                                                     Length(name),
  3674.                                                     strDesc);
  3675.                                                 
  3676.         IF (err=noErr) THEN
  3677.             err := SendAESetObjProp(selTextObj, 
  3678.                                                             pFont,
  3679.                                                             strDesc,
  3680.                                                             theAddress);                                                            
  3681.     END; (* IssueFontCommand *)
  3682.     
  3683. (*
  3684.     Window property routines
  3685. *)
  3686.  
  3687. PROCEDURE IssueZoomCommand(whichWindow:WindowPtr; whichPart:INTEGER);
  3688.     VAR zoomBool         : Boolean;
  3689.             zoomDesc         : AEDesc;
  3690.             selfAddr         : AEAddressDesc;
  3691.             frontWinObj : AEDesc;
  3692.             err                    : OSErr;
  3693.     
  3694.     BEGIN
  3695.         err := MakeSelfAddress(selfAddr);
  3696.         
  3697.         err := MakeWindowObj(whichWindow, frontWinObj);
  3698.         
  3699.         zoomBool := (whichPart=inZoomOut);
  3700.     
  3701.         err := AECreateDesc(typeBoolean,
  3702.                                                 @zoomBool,
  3703.                                                 sizeOf(zoomBool),
  3704.                                                 zoomDesc);
  3705.                                                 
  3706.         err := SendAESetObjProp(frontWinObj, 
  3707.                                                         pIsZoomed,
  3708.                                                         zoomDesc,
  3709.                                                         selfAddr);                                                            
  3710.     END; (* IssueZoomCommand *)
  3711.     
  3712. PROCEDURE IssueCloseCommand(whichWindow:WindowPtr);
  3713.     VAR selfAddr                     : AEAddressDesc;
  3714.             frontWinObj             : AEDesc;
  3715.             err                                : OSErr;
  3716.             ignoreErr                 : OSErr;
  3717.             closeCommandEvent : AppleEvent;
  3718.             ignoreReply                : AppleEvent;
  3719.     
  3720.     BEGIN
  3721.         
  3722.         frontWinObj.dataHandle:=NIL;
  3723.         
  3724.         err := MakeSelfAddress(selfAddr);
  3725.         
  3726.         err := MakeWindowObj(whichWindow, frontWinObj);
  3727.                                                             
  3728.         err := AECreateAppleEvent( kAECoreSuite, kAEClose, selfAddr, 0, 0, closeCommandEvent) ;                
  3729.         
  3730.         { add parameter - the window to close }    
  3731.         IF (err=noErr) THEN
  3732.             err := AEPutParamDesc(closeCommandEvent,keyDirectObject,frontWinObj);
  3733.             
  3734.         IF (err=noErr) THEN
  3735.             err := AESend(closeCommandEvent,ignoreReply,kAENoReply+kAEAlwaysInteract,KAEHighPriority,10000,nil, nil);
  3736.     
  3737.         IF (closeCommandEvent.dataHandle<>NIL) THEN
  3738.             ignoreErr := AEDisposeDesc(closeCommandEvent);
  3739.         
  3740.         IF (selfAddr.dataHandle<>NIL) THEN
  3741.             err := AEDisposeDesc(selfAddr);
  3742.             
  3743.         IF (frontWinObj.dataHandle<>NIL) THEN
  3744.             err := AEDisposeDesc(frontWinObj);
  3745.             
  3746.     END; (* IssueCloseCommand *)
  3747.     
  3748. PROCEDURE IssueSizeWindow(whichWindow:WindowPtr; newHSize:INTEGER; newVSize:INTEGER);
  3749.     VAR sizeRect         : Rect;
  3750.             contentRect : Rect;
  3751.             edgeSize    : INTEGER;
  3752.             sizeDesc         : AEDesc;
  3753.             selfAddr         : AEAddressDesc;
  3754.             frontWinObj : AEDesc;
  3755.             err                    : OSErr;
  3756.     
  3757.     BEGIN
  3758.         sizeRect    := WindowPeek(whichWindow)^.strucRgn^^.rgnBBox;
  3759.         contentRect := WindowPeek(whichWindow)^.contRgn^^.rgnBBox;
  3760.         
  3761.         edgeSize := sizeRect.right-sizeRect.left-(contentRect.right-contentRect.left);
  3762.         sizeRect.right := sizeRect.left+newHSize+edgeSize;
  3763.         
  3764.         edgeSize := sizeRect.bottom-sizeRect.top-(contentRect.bottom-contentRect.top);
  3765.         sizeRect.bottom := sizeRect.top+newVSize+edgeSize;
  3766.         
  3767.         err := MakeSelfAddress(selfAddr);
  3768.         
  3769.         err := MakeWindowObj(whichWindow, frontWinObj);
  3770.             
  3771.         IF (err=noErr) THEN
  3772.             err := AECreateDesc(typeQDRectangle,
  3773.                                                     @sizeRect,
  3774.                                                     sizeOf(sizeRect),
  3775.                                                     sizeDesc);
  3776.                                                     
  3777.       IF (err=noErr) THEN
  3778.             err := SendAESetObjProp(frontWinObj, 
  3779.                                                             pBounds,
  3780.                                                             sizeDesc,
  3781.                                                             selfAddr);                                                            
  3782.     END; (*IssueSizeWindow*)
  3783.     
  3784. PROCEDURE IssueMoveWindow(whichWindow:windowPtr; sizeRect:Rect);
  3785.     VAR sizeDesc         : AEDesc;
  3786.             selfAddr         : AEAddressDesc;
  3787.             frontWinObj : AEDesc;
  3788.             err                    : OSErr;
  3789.     
  3790.     BEGIN        
  3791.         err := MakeSelfAddress(selfAddr);
  3792.         
  3793.         err := MakeWindowObj(whichWindow, frontWinObj);
  3794.             
  3795.         IF (err=noErr) THEN
  3796.             err := AECreateDesc(typeQDRectangle,
  3797.                                                     @sizeRect,
  3798.                                                     sizeOf(sizeRect),
  3799.                                                     sizeDesc);
  3800.         IF (err=noErr) THEN
  3801.             err := SendAESetObjProp(frontWinObj, 
  3802.                                                             pBounds,
  3803.                                                             sizeDesc,
  3804.                                                             selfAddr);                                                            
  3805.     END; (*IssueMoveWindow*)
  3806.  
  3807. PROCEDURE IssuePageSetupWindow(whichWindow:windowPtr; thePageSetup:TPrint);
  3808.     VAR sizeDesc         : AEDesc;
  3809.             selfAddr         : AEAddressDesc;
  3810.             frontWinObj : AEDesc;
  3811.             err                    : OSErr;
  3812.     
  3813.     BEGIN        
  3814.         err := MakeSelfAddress(selfAddr);
  3815.         
  3816.         err := MakeWindowObj(whichWindow, frontWinObj);
  3817.         
  3818.         IF (err=noErr) THEN
  3819.             err := AECreateDesc(typeTPrint,
  3820.                                                     @thePageSetup,
  3821.                                                     sizeOf(thePageSetup),
  3822.                                                     sizeDesc);
  3823.       IF (err=noErr) THEN
  3824.             err := SendAESetObjProp(frontWinObj, 
  3825.                                                             pPageSetup,
  3826.                                                             sizeDesc,
  3827.                                                             selfAddr);                                                            
  3828.     END; (*IssuePageSetupWindow*)
  3829.     
  3830. PROCEDURE IssueShowBorders(whichWindow:windowPtr; showBorders:BOOLEAN);
  3831.     VAR sizeDesc         : AEDesc;
  3832.             selfAddr         : AEAddressDesc;
  3833.             frontWinObj : AEDesc;
  3834.             err                    : OSErr;
  3835.     
  3836.     BEGIN        
  3837.         err := MakeSelfAddress(selfAddr);
  3838.         
  3839.         err := MakeWindowObj(whichWindow, frontWinObj);
  3840.             
  3841.         IF (err=noErr) THEN
  3842.             err := AECreateDesc(typeBoolean,
  3843.                                                     @showBorders,
  3844.                                                     sizeOf(showBorders),
  3845.                                                     sizeDesc);
  3846.         IF (err=noErr) THEN
  3847.             err := SendAESetObjProp(frontWinObj, 
  3848.                                                             pShowBorders,
  3849.                                                             sizeDesc,
  3850.                                                             selfAddr);                                                            
  3851.     END; (*IssueShowBorders*)
  3852.     
  3853. PROCEDURE IssuePrintWindow(whichWindow:windowPtr);
  3854.     VAR selfAddr                     : AEAddressDesc;
  3855.             frontWinObj             : AEDesc;
  3856.             err                                : OSErr;
  3857.             ignoreErr                 : OSErr;
  3858.             printCommandEvent : AppleEvent;
  3859.             ignoreReply                : AppleEvent;
  3860.     
  3861.     BEGIN        
  3862.         err := MakeSelfAddress(selfAddr);
  3863.         
  3864.         err := MakeWindowObj(whichWindow, frontWinObj);
  3865.                                                             
  3866.         err := AECreateAppleEvent( kCoreEventClass, kAEPrintDocuments, selfAddr, 0, 0, printCommandEvent) ;                
  3867.  
  3868.         { 
  3869.             add parameter - the window to print
  3870.         }    
  3871.  
  3872.         IF (err=noErr) THEN
  3873.             err := AEPutParamDesc(printCommandEvent,keyDirectObject,frontWinObj);
  3874.             
  3875.         IF (err=noErr) THEN
  3876.             err := AESend(printCommandEvent,ignoreReply,kAENoReply+kAEAlwaysInteract,KAEHighPriority,10000,nil, nil);
  3877.     
  3878.         err := AEDisposeDesc(printCommandEvent);
  3879.         
  3880.         IF (selfAddr.dataHandle<>NIL) THEN
  3881.             err := AEDisposeDesc(selfAddr);
  3882.             
  3883.         IF (frontWinObj.dataHandle<>NIL) THEN
  3884.             err := AEDisposeDesc(frontWinObj);
  3885.     END; (*IssuePrintWindow*)
  3886.     
  3887. FUNCTION IssueAEOpenDoc(myFSSpec: FSSpec):OSErr;
  3888. { send OpenDocs AppleEvent to myself, with a one-element list
  3889.   containing the given file spec
  3890.  
  3891.   NOTES:    the core AEOpenDocs event is defined as taking a list of
  3892.           aliases (not file specs) as its direct parameter.  However,
  3893.             we can send the file spec instead and depend on AppleEvents'
  3894.             automatic coercion.  In fact, we don't really even have to put 
  3895.             in a list; AppleEvents will coerce a descriptor into a 1-element
  3896.             list if called for.  In this routine, though, we'll make the
  3897.             list for demonstration purposes.
  3898. }
  3899.  
  3900. VAR myAppleEvent:    AppleEvent;
  3901.         defReply        : AppleEvent;
  3902.         docList            : AEDescList;
  3903.         selfAddr        : AEAddressDesc;
  3904.         myErr                : OSErr;
  3905.         
  3906. BEGIN
  3907.     myAppleEvent.dataHandle := NIL;
  3908.     docList.dataHandle  := NIL;
  3909.     selfAddr.dataHandle := NIL;
  3910.     defReply.dataHandle := NIL;
  3911.       
  3912.     {
  3913.         Create empty list and add one file spec
  3914.     }
  3915.   myErr := AECreateList(NIL,0,FALSE,docList);
  3916.     
  3917.     IF (myErr=noErr) THEN
  3918.         myErr := AEPutPtr(docList,1,typeFSS,@myFSSpec,SizeOf(myFSSpec));
  3919.         
  3920.     {
  3921.         Create a self address to send it to
  3922.     }
  3923.     IF (myErr=noErr) THEN
  3924.       myErr := MakeSelfAddress(selfAddr);
  3925.         
  3926.     IF (myErr=noErr) THEN
  3927.         myErr := AECreateAppleEvent(kCoreEventClass,
  3928.                                                                 kAEOpenDocuments,
  3929.                                                                 selfAddr,
  3930.                                                                 kAutoGenerateReturnID,
  3931.                                                                 kAnyTransactionID,
  3932.                                                                 myAppleEvent);
  3933.  
  3934.   { 
  3935.         Put Params into our event and send it
  3936.     }
  3937.   IF (myErr = noErr) THEN
  3938.         myErr := AEPutParamDesc(myAppleEvent,
  3939.                                                         keyDirectObject,
  3940.                                                         docList);
  3941.  
  3942.   myErr := AESend(myAppleEvent,
  3943.                                     defReply,
  3944.                                     kAENoReply+kAEAlwaysInteract,
  3945.                                     kAENormalPriority,
  3946.                                     kAEDefaultTimeOut,
  3947.                                     NIL,
  3948.                                     NIL);
  3949.       
  3950.     IssueAEOpenDoc := myErr;
  3951.     
  3952.     IF (selfAddr.dataHandle<>NIL) THEN
  3953.         myErr := AEDisposeDesc(selfAddr);
  3954.         
  3955.     IF (myAppleEvent.dataHandle<>NIL) THEN
  3956.         myErr := AEDisposeDesc(myAppleEvent);
  3957.         
  3958.     IF (docList.dataHandle<>NIL) THEN
  3959.         myErr := AEDisposeDesc(docList);
  3960.         
  3961. END;    { IssueAEOpenDoc }
  3962.  
  3963. PROCEDURE IssueAENewWindow;
  3964.  
  3965. (* 
  3966.     send the New Element event to myself with a null container
  3967. *)
  3968.  
  3969. VAR myAppleEvent    :    AppleEvent;
  3970.         defReply            :    AppleEvent;
  3971.         selfAddr            : AEAddressDesc;
  3972.         myErr                    : OSErr;
  3973.         ignoreErr         : OSErr;
  3974.         elemClass            : DescType;
  3975.         
  3976. BEGIN
  3977.     myAppleEvent.dataHandle := NIL;
  3978.     
  3979.     (*
  3980.         Create the address of us
  3981.     *)
  3982.     
  3983.     myErr := MakeSelfAddress(selfAddr);
  3984.     
  3985.   (*
  3986.         create event 
  3987.     *)
  3988.     
  3989.   myErr := AECreateAppleEvent(kAECoreSuite,
  3990.                                                             kAECreateElement,
  3991.                                                             selfAddr,
  3992.                                                             kAutoGenerateReturnID,
  3993.                                                             kAnyTransactionID,
  3994.                                                             myAppleEvent);  
  3995.   (*
  3996.         attach desired class of new element
  3997.     *)
  3998.     
  3999.     elemClass := cWindow;
  4000.     
  4001.   IF (myErr = noErr) THEN
  4002.       myErr := AEPutParamPtr(myAppleEvent,
  4003.                                                      keyAEObjectClass,
  4004.                                                      typeType,
  4005.                                                      @elemClass,
  4006.                                                      SizeOf(elemClass));
  4007.       
  4008.   (*
  4009.         send the event 
  4010.     *)
  4011.     
  4012.   IF (myErr = noErr) THEN
  4013.         myErr := AESend(myAppleEvent,
  4014.                                         defReply,
  4015.                                         kAENoReply+kAENeverInteract,
  4016.                                         kAENormalPriority,
  4017.                                         kAEDefaultTimeOut,
  4018.                                         NIL,
  4019.                                         NIL);
  4020.   (*
  4021.         Clean up - reply never created so don't throw away
  4022.     *)
  4023.     IF (selfAddr.dataHandle<>NIL) THEN
  4024.         ignoreErr := AEDisposeDesc(selfAddr);
  4025.         
  4026.     IF (myAppleEvent.dataHandle<>NIL) THEN
  4027.         ignoreErr := AEDisposeDesc(myAppleEvent);
  4028.                 
  4029. END;    { IssueAENewWindow }
  4030.  
  4031. FUNCTION IssueSaveCommand(theWindow    : WindowPtr;
  4032.                                                   where     : FSSpecPtr):OSErr;
  4033. (*
  4034.     send an AppleEvent Save Event to myself
  4035. *)
  4036.  
  4037. VAR windowObj            : AEDesc;
  4038.         myAppleEvent    : AppleEvent;
  4039.         defReply            : AppleEvent;
  4040.         myErr                    : OSErr;
  4041.         ignoreErr         : OSErr;
  4042.         selfAddr            : AEAddressDesc;
  4043.         
  4044. BEGIN
  4045.     windowObj.dataHandle := NIL;
  4046.     myAppleEvent.dataHandle := NIL;
  4047.     
  4048.     myErr := MakeWindowObj(theWindow, windowObj);
  4049.             
  4050.     IF (myErr=noErr) THEN
  4051.         myErr := MakeSelfAddress(selfAddr);
  4052.         
  4053.   (*
  4054.         Build event
  4055.     *)
  4056.     
  4057.   IF (myErr = noErr) THEN
  4058.         myErr := AECreateAppleEvent(kAECoreSuite,
  4059.                                                                 kAESave,
  4060.                                                                 selfAddr,
  4061.                                                                 kAutoGenerateReturnID,
  4062.                                                                 kAnyTransactionID,
  4063.                                                                 myAppleEvent);
  4064.       
  4065.   (*
  4066.         say which window
  4067.     *)
  4068.     
  4069.   IF (myErr=noErr) THEN
  4070.         myErr := AEPutParamDesc(myAppleEvent,
  4071.                                                         keyDirectObject,
  4072.                                                         windowObj);
  4073.   
  4074.   (*
  4075.         add optional file param if we need to
  4076.     *)
  4077.     
  4078.   IF (where<>NIL) THEN
  4079.         IF (myErr=noErr) THEN
  4080.             myErr := AEPutParamPtr(myAppleEvent,
  4081.                                                          keyAEDestination,
  4082.                                                          typeFSS,
  4083.                                                          @where^,
  4084.                                                          SizeOf(where^));
  4085.         
  4086.   (*
  4087.         send the event
  4088.     *)
  4089.   IF (myErr=noErr) THEN
  4090.         myErr := AESend(myAppleEvent,
  4091.                                         defReply,
  4092.                                         kAENoReply+kAENeverInteract,
  4093.                                         kAENormalPriority,
  4094.                                         kAEDefaultTimeOut,
  4095.                                         NIL,
  4096.                                         NIL);
  4097.       
  4098.     IssueSaveCommand := myErr;
  4099.     
  4100.     IF (selfAddr.dataHandle<>NIL) THEN
  4101.         myErr := AEDisposeDesc(selfAddr);
  4102.     
  4103.     IF (windowObj.dataHandle<>NIL) THEN
  4104.         myErr := AEDisposeDesc(windowObj);
  4105.         
  4106.     IF (myAppleEvent.dataHandle<>NIL) THEN
  4107.         myErr := AEDisposeDesc(myAppleEvent);
  4108. END;    { IssueSaveCommand }
  4109.  
  4110. FUNCTION IssueRevertCommand(theWindow    : WindowPtr):OSErr;
  4111. (*
  4112.     send an AppleEvent Revert Event to myself
  4113. *)
  4114.  
  4115. VAR windowObj            : AEDesc;
  4116.         myAppleEvent    : AppleEvent;
  4117.         defReply            : AppleEvent;
  4118.         myErr                    : OSErr;
  4119.         selfAddr            : AEAddressDesc;
  4120.         
  4121. BEGIN
  4122.     windowObj.dataHandle := NIL;
  4123.     myAppleEvent.dataHandle := NIL;
  4124.     
  4125.     myErr := MakeWindowObj(theWindow, windowObj);
  4126.             
  4127.     IF (myErr=noErr) THEN
  4128.         myErr := MakeSelfAddress(selfAddr);
  4129.         
  4130.   (*
  4131.         Build event
  4132.     *)
  4133.     
  4134.   IF (myErr = noErr) THEN
  4135.         myErr := AECreateAppleEvent(kAEMiscStandards,
  4136.                                                                 kAERevert,
  4137.                                                                 selfAddr,
  4138.                                                                 kAutoGenerateReturnID,
  4139.                                                                 kAnyTransactionID,
  4140.                                                                 myAppleEvent);
  4141.   (*
  4142.         say which window
  4143.     *)
  4144.     
  4145.   IF (myErr=noErr) THEN
  4146.         myErr := AEPutParamDesc(myAppleEvent,
  4147.                                                         keyDirectObject,
  4148.                                                         windowObj);
  4149.   (*
  4150.         send the event
  4151.     *)
  4152.   IF (myErr=noErr) THEN
  4153.         myErr := AESend(myAppleEvent,
  4154.                                         defReply,
  4155.                                         kAENoReply+kAENeverInteract,
  4156.                                         kAENormalPriority,
  4157.                                         kAEDefaultTimeOut,
  4158.                                         NIL,
  4159.                                         NIL);
  4160.       
  4161.     IssueRevertCommand := myErr;
  4162.     
  4163.     IF (windowObj.dataHandle<>NIL) THEN
  4164.         myErr := AEDisposeDesc(windowObj);
  4165.         
  4166.     IF (myAppleEvent.dataHandle<>NIL) THEN
  4167.         myErr := AEDisposeDesc(myAppleEvent);
  4168.         
  4169.     IF (selfAddr.dataHandle<>NIL) THEN
  4170.         myErr := AEDisposeDesc(selfAddr);
  4171.         
  4172. END;    { IssueRevertCommand }
  4173.  
  4174. (*
  4175.     Name : IssueQuitCommand
  4176.     Purpose : Sends self a Quit AppleEvent
  4177. *)
  4178. FUNCTION IssueQuitCommand:OSErr;
  4179.     VAR
  4180.         myAppleEvent  : AppleEvent;
  4181.         defReply      : AppleEvent;
  4182.         myErr         : OSErr;
  4183.         ignoreErr     : OSErr;
  4184.         selfAddr      : AEAddressDesc;
  4185.         mySaveOpt     : DescType;
  4186.         
  4187.     BEGIN
  4188.         myAppleEvent.dataHandle := nil;
  4189.         selfAddr.dataHandle     := nil;
  4190.                             
  4191.         myErr := MakeSelfAddress(selfAddr);
  4192.             
  4193.         (*
  4194.             Build event
  4195.         *)
  4196.         
  4197.         IF (myErr = noErr) THEN 
  4198.             myErr  := AECreateAppleEvent(kCoreEventClass,
  4199.                                                                      kAEQuitApplication,
  4200.                                                                      selfAddr,
  4201.                                                                      kAutoGenerateReturnID,
  4202.                                                                      kAnyTransactionID,
  4203.                                                                      myAppleEvent);
  4204.         (*
  4205.             say which save option
  4206.         *)
  4207.         
  4208.         mySaveOpt := kAEAsk;
  4209.         
  4210.         IF (myErr = noErr) THEN
  4211.             myErr := AEPutParamPtr(myAppleEvent,
  4212.                                                          keyAESaveOptions,
  4213.                                                          typeEnumerated,
  4214.                                                          Ptr(@mySaveOpt),
  4215.                                                          sizeof(mySaveOpt));
  4216.         (*
  4217.             send the event
  4218.         *)
  4219.         IF (myErr=noErr) THEN 
  4220.             myErr := AESend(myAppleEvent,
  4221.                                             defReply,
  4222.                                             kAENoReply+kAEAlwaysInteract,
  4223.                                             kAENormalPriority,
  4224.                                             kAEDefaultTimeout,
  4225.                                             nil,
  4226.                                             nil);
  4227.                         
  4228.         IF (myAppleEvent.dataHandle<>NIL) THEN 
  4229.             ignoreErr := AEDisposeDesc(myAppleEvent);
  4230.             
  4231.         IF (selfAddr.dataHandle<>NIL) THEN 
  4232.             ignoreErr := AEDisposeDesc(selfAddr);
  4233.             
  4234.         IssueQuitCommand := myErr;
  4235.     END;    (* IssueQuitCommand *)
  4236.  
  4237. (*
  4238.     Name         : IssueCreatePublisher
  4239.     Purpose : Interact with user to get Publisher info
  4240.                         and the IssueAECommand to Publish currect selection
  4241. *)
  4242. PROCEDURE IssueCreatePublisher(whichDoc:DPtr);
  4243.     VAR selfAddr                         : AEAddressDesc;
  4244.             selTextObj                   : AEDesc;
  4245.             err                                    : OSErr;
  4246.             ignoreErr                        : OSErr;
  4247.             publishCommandEvent : AppleEvent;
  4248.             ignoreReply                    : AppleEvent;
  4249.     
  4250.     BEGIN
  4251.       publishCommandEvent.dataHandle := NIL;
  4252.         selfAddr.dataHandle   := NIL;
  4253.         selTextObj.dataHandle := NIL;
  4254.         
  4255.         err := MakeSelfAddress(selfAddr);
  4256.         IF (err=noErr) THEN
  4257.             err := MakeSelectedTextObj(whichDoc^.theWindow, whichDoc^.theText, selTextObj);
  4258.                                                             
  4259.         err := AECreateAppleEvent( kAEMiscStandards, kAECreatePublisher, selfAddr, 0, 0, publishCommandEvent) ;                
  4260.  
  4261.         { 
  4262.             add parameter - the text to publish
  4263.         }    
  4264.  
  4265.         IF (err=noErr) THEN
  4266.             err := AEPutParamDesc(publishCommandEvent,keyDirectObject,selTextObj);
  4267.             
  4268.         IF (err=noErr) THEN
  4269.             err := AESend(publishCommandEvent,ignoreReply,kAENoReply+kAEAlwaysInteract,KAEHighPriority,10000,nil, nil);
  4270.     
  4271.         IF (publishCommandEvent.dataHandle<>NIL) THEN
  4272.             err := AEDisposeDesc(publishCommandEvent);
  4273.         
  4274.         IF (selTextObj.dataHandle<>NIL) THEN
  4275.             err := AEDisposeDesc(selTextObj);
  4276.             
  4277.         IF (selfAddr.dataHandle<>NIL) THEN
  4278.             err := AEDisposeDesc(selfAddr);
  4279.     END; (*IssueCreatePublisher*)
  4280.     
  4281.  
  4282. FUNCTION PoseSizeDialog(VAR whatSize:longint):BOOLEAN;
  4283.  
  4284. CONST kOK                = 1;
  4285.       kCancel            = 2;
  4286.         kOtherSize         = 4;
  4287.             kOutlineItem     = 5;
  4288.  
  4289. VAR savedPort : GrafPtr;
  4290.     aDialog   : DialogPtr;
  4291.       aString   : STR255;
  4292.       theSize   : LONGINT;
  4293.       itemHit   : INTEGER;
  4294.  
  4295. BEGIN
  4296.   GetPort(savedPort);
  4297.   aDialog := GetNewDialog(1004, nil, Pointer(-1));
  4298.   ShowWindow(aDialog);
  4299.   SetPort(aDialog);
  4300.     
  4301.   AdornDefaultButton(aDialog, kOutlineItem);
  4302.    
  4303.   {set the edittext button to contain the right size}
  4304.   NumToString(whatSize, aString);
  4305.   SetText(aDialog, kOtherSize, aString);
  4306.  
  4307.   REPEAT
  4308.     ModalDialog(nil, itemHit);
  4309.   UNTIL ((itemHit = kOK) OR
  4310.                  (itemHit = kCancel));
  4311.   
  4312.   IF itemHit = kOK THEN 
  4313.         RetrieveText(aDialog, KOtherSize, aString);
  4314.  
  4315.   DisposDialog(aDialog);
  4316.   SetPort(savedPort);
  4317.   
  4318.   IF (itemHit = kOK) THEN
  4319.    BEGIN
  4320.        {set the new size of the text}
  4321.      StringToNum(aString, whatSize);
  4322.          IF (whatSize<1) OR
  4323.             (whatSize>2000) THEN
  4324.              whatSize := 12;
  4325.    END;
  4326.     PoseSizeDialog := (itemHit = kOK);
  4327. END;
  4328.     
  4329. PROCEDURE IssueSizeCommand(theDocument:DPtr;theItem:INTEGER);
  4330.     VAR name         : Str255;
  4331.             sizeDesc      : AEDesc;
  4332.             theAddress : AEAddressDesc;
  4333.             err                 : OSErr;
  4334.             selTextObj : AEDesc;
  4335.             
  4336.             (*
  4337.                 Vars to do with menu processing
  4338.             *)
  4339.             lastSize      : INTEGER;
  4340.             upItem        : INTEGER;
  4341.             downItem         : INTEGER;
  4342.             otherItem     : INTEGER;
  4343.             theSize     : longint;
  4344.             theStyle        : TextStyle;
  4345.             lineHeight    : INTEGER;
  4346.             fontAscent    : INTEGER;
  4347.             
  4348.     BEGIN
  4349.         err := MakeSelfAddress(theAddress);
  4350.         
  4351.         err := MakeSelectedTextObj(theDocument^.theWindow, theDocument^.theText, selTextObj);        
  4352.  
  4353.      {check IF the item is on the Size menu}
  4354.      {remembering that we can add and delete items from it}
  4355.      lastSize  := CountMItems(myMenus[sizeM]) - 5;
  4356.      upItem    := lastSize + 2;
  4357.      downItem  := upItem + 1;
  4358.      otherItem := downItem + 2;
  4359.       
  4360.      TEGetStyle(theDocument^.theText^^.selStart, theStyle, lineHeight, fontAscent, theDocument^.theText);
  4361.         
  4362.      GetItem(myMenus[sizeM], theItem, name);
  4363.      
  4364.      IF theItem <= lastSize THEN
  4365.        BEGIN
  4366.          GetItem(myMenus[sizeM], theItem, name);
  4367.        StringToNum(name, theSize);
  4368.        END
  4369.      ELSE
  4370.        IF theItem = upItem THEN 
  4371.          theSize := theStyle.tsSize+1
  4372.          ELSE
  4373.             IF theItem = downItem THEN 
  4374.                  theSize := theStyle.tsSize-1
  4375.                  ELSE 
  4376.                     If (theItem = otherItem) THEN
  4377.                         BEGIN
  4378.                           theSize := theStyle.tsSize;
  4379.                             IF NOT PoseSizeDialog(theSize) THEN
  4380.                                 Exit(IssueSizeCommand);
  4381.                         END;
  4382.         
  4383.         IF (err=noErr) THEN
  4384.             err := CreateOffsetDescriptor(theSize, sizeDesc);
  4385.  
  4386.         IF (err=noErr) THEN
  4387.             err := SendAESetObjProp(selTextObj, 
  4388.                                                             pPointSize,
  4389.                                                             sizeDesc,
  4390.                                                             theAddress);                                                            
  4391.     END; (*IssueSizeCommand*)
  4392.     
  4393. PROCEDURE IssueStyleCommand(theDocument:DPtr;theItem:INTEGER);
  4394.     VAR theFace          : Style;
  4395.             err                     : OSErr;
  4396.             result           : AEDesc;
  4397.             selfAddr         : AEAddressDesc;
  4398.             selTextObj     : AEDesc;
  4399.             theStyle        : TextStyle;
  4400.             lineHeight    : INTEGER;
  4401.             fontAscent    : INTEGER;
  4402.             
  4403.     BEGIN
  4404.         TEGetStyle(theDocument^.theText^^.selStart, theStyle, lineHeight, fontAscent, theDocument^.theText);
  4405.         
  4406.         theFace := [];
  4407.     case theItem of
  4408.             cPlain            : theFace := [];
  4409.             cBold                : theFace := [bold];
  4410.             cItalic            : theFace := [italic];
  4411.             cUnderLine    : theFace := [underline];
  4412.             cOutline        : theFace := [outline];
  4413.             cShadow            : theFace := [shadow];
  4414.             cCondense        : theFace := [condense];
  4415.             cExtEND            : theFace := [extend];
  4416.     END;{of case}
  4417.  
  4418.     IF (theFace = []) THEN
  4419.       err := BuildTypeTextStylesDesc([], [bold,italic,underline,outline,shadow,condense,extend], result)
  4420.     ELSE
  4421.       IF (theFace * theStyle.tsFace)<>[] THEN
  4422.               err := BuildTypeTextStylesDesc([], theFace, result)
  4423.             ELSE
  4424.               err := BuildTypeTextStylesDesc(theFace, [], result);
  4425.         
  4426.         err := MakeSelfAddress(selfAddr);
  4427.         
  4428.         IF (err=noErr) THEN
  4429.             err := MakeSelectedTextObj(theDocument^.theWindow, theDocument^.theText, selTextObj);
  4430.         
  4431.         IF (err=noErr) THEN
  4432.             err := SendAESetObjProp(selTextObj, 
  4433.                                                             pTextStyles,
  4434.                                                             result,
  4435.                                                             selfAddr);
  4436.         
  4437.     END; (* IssueStyleCommand *)
  4438.  
  4439. CONST
  4440.             ETX = $03; (* Enter key on keyboard or keypad *)
  4441.             BS  = $08; (* Backspace key on keyboard       *)
  4442.             HT  = $09; (* Tab key on keyboard             *)
  4443.             CR  = $0D; (* Return key on keyboard          *)
  4444.             ESC = $1B; (* Clear key on keypad             *)
  4445.             FS  = $1C; (* Left arrow key on keypad        *)
  4446.             GS  = $1D; (* Right arrow key on keypad       *)
  4447.             RS  = $1E; (* Up arrow key on keypad          *)
  4448.             US  = $1F; (* Down arrow key on keypad        *)
  4449.  
  4450. FUNCTION IssueSetDataObjToBufferContents(VAR theObj:AEDesc):OSErr;
  4451.     VAR
  4452.       myErr       : OSErr;
  4453.         ignoreErr   : OSErr;
  4454.         theAddress  : AEAddressDesc;
  4455.         myAppleEvent: AppleEvent;
  4456.         defReply    : AppleEvent;
  4457.  
  4458.     BEGIN
  4459.         myErr := MakeSelfAddress(theAddress);
  4460.         
  4461.         (* create event *)
  4462.         
  4463.         IF (myErr=noErr) THEN
  4464.             myErr:= AECreateAppleEvent(kAECoreSuite,
  4465.                                                                  kAESetData,
  4466.                                                                  theAddress,
  4467.                                                                  0,
  4468.                                                                  0,
  4469.                                                                  myAppleEvent);
  4470.             
  4471.         (* add prop obj spec to the event *)
  4472.         
  4473.         if (myErr=noErr) THEN
  4474.             myErr:= AEPutParamDesc(myAppleEvent, keyDirectObject, theObj);
  4475.         
  4476.         (* add prop data to the event *)
  4477.         
  4478.         if (myErr=noErr) THEN
  4479.             myErr:= AEPutParamPtr(myAppleEvent,
  4480.                                                         keyAEData,
  4481.                                                         typeChar,
  4482.                                                         Ptr(gTypingBuffer),
  4483.                                                         gCharsInBuffer);
  4484.                                                         
  4485.         (* send event *)
  4486.         
  4487.         (* only send the event if recording is implemented, otherwise the event will *)
  4488.         (* be sent twice *)
  4489.         
  4490.         if (gRecordingImplemented = TRUE) THEN
  4491.           if (myErr=noErr) THEN
  4492.               myErr:= AESend(myAppleEvent,
  4493.                                          defReply,
  4494.                                          kAENoReply+kAEDontExecute,
  4495.                                          kAENormalPriority,
  4496.                                          kAEDefaultTimeout,
  4497.                                          nil,
  4498.                                          nil);
  4499.  
  4500.         if (theAddress.dataHandle<>NIL) THEN
  4501.             ignoreErr:= AEDisposeDesc(theAddress);
  4502.             
  4503.         IF (myAppleEvent.dataHandle<>NIL) THEN
  4504.             ignoreErr:= AEDisposeDesc(myAppleEvent);
  4505.             
  4506.         IssueSetDataObjToBufferContents := myErr;
  4507.     END;
  4508.  
  4509. PROCEDURE AddKeyToTypingBuffer(theDocument : DPtr;theKey : CHAR);
  4510.     VAR
  4511.         myErr     : OSErr;
  4512.         ignoreErr : OSErr;
  4513.         
  4514.     BEGIN
  4515.         IF ((theKey=CHR(BS)) OR
  4516.             (theKey=CHR(FS)) OR
  4517.                 (theKey=CHR(GS)) OR 
  4518.                 (theKey=CHR(RS)) OR
  4519.                 (theKey=CHR(US))) THEN
  4520.             BEGIN
  4521.                 FlushAndRecordTypingBuffer;
  4522.                 IF (theKey=CHR(BS)) THEN
  4523.                     BEGIN
  4524.                         IF (theDocument^.theText^^.selStart<>theDocument^.theText^^.selEnd) THEN
  4525.                             BEGIN
  4526.                                 myErr:= MakeTextObj(theDocument^.theWindow,
  4527.                                                                         theDocument^.theText^^.selStart,
  4528.                                                                         theDocument^.theText^^.selEnd,
  4529.                                                                         gTypingTargetObject);
  4530.                             END
  4531.                         ELSE
  4532.                             BEGIN
  4533.                                 myErr:= MakeTextObj(theDocument^.theWindow,
  4534.                                                                         theDocument^.theText^^.selStart-1,
  4535.                                                                         theDocument^.theText^^.selStart,
  4536.                                                                         gTypingTargetObject);
  4537.                             END;
  4538.                             
  4539.                     myErr := IssueSetDataObjToBufferContents(gTypingTargetObject);
  4540.                         
  4541.                         ignoreErr := AEDisposeDesc(gTypingTargetObject);
  4542.                         
  4543.                         gTypingTargetObject.dataHandle := nil;
  4544.                     END
  4545.             END
  4546.         ELSE
  4547.             BEGIN
  4548.                 IF (gCharsInBuffer=0) THEN
  4549.                     myErr:= MakeSelectedTextObj(theDocument^.theWindow,
  4550.                                                                             theDocument^.theText,
  4551.                                                                             gTypingTargetObject);
  4552.  
  4553.                 gTypingBuffer^[gCharsInBuffer] := theKey;
  4554.                 gCharsInBuffer := gCharsInBuffer +1;
  4555.             END;
  4556.     END;
  4557.     
  4558. PROCEDURE FlushAndRecordTypingBuffer;
  4559.     VAR
  4560.         myErr     : OSErr;
  4561.         ignoreErr : OSErr;
  4562.         
  4563.   BEGIN
  4564.         IF (gCharsInBuffer <> 0) THEN
  4565.             BEGIN
  4566.                 myErr:= IssueSetDataObjToBufferContents(gTypingTargetObject);
  4567.                 
  4568.                 IF (gTypingTargetObject.dataHandle<>NIL) THEN
  4569.                     ignoreErr:= AEDisposeDesc(gTypingTargetObject);
  4570.             END;
  4571.             
  4572.         gCharsInBuffer:= 0;
  4573.         gTypingTargetObject.dataHandle:= nil;
  4574.     END;
  4575.     
  4576.  
  4577. {*****************************************************************************}
  4578. {
  4579.     Object Accessors
  4580. }
  4581.     
  4582. FUNCTION WindowFromNullAccessor(wantClass            : DescType;
  4583.                                                                 container            : AEDesc;
  4584.                                                             containerClass: DescType;
  4585.                                                                 form                    : DescType; 
  4586.                                                                 selectionData    : AEDesc;
  4587.                                                                 VAR value            : AEDesc;
  4588.                                                                 theRefCon            : LongInt):  OSErr;
  4589.  
  4590. VAR myErr                :    OSErr;
  4591.         actSize            :    Size;
  4592.         nameStr            :    Str255;
  4593.         theWindow        :    WindowToken;
  4594.         index                :    INTEGER;
  4595.         resultDesc     : AEDesc;
  4596.         
  4597. BEGIN
  4598.   myErr := -1708;    { or whatever }
  4599.   value.dataHandle      := nil;
  4600.     resultDesc.dataHandle := nil;
  4601.   
  4602.   { 
  4603.         should only be called with wantClass = cWindow and
  4604.       with containerClass = typeNull or typeMyAppl.
  4605.         Currently accept as either formName or formAbsolutePosition
  4606.     }
  4607.     
  4608.   IF (wantClass <> cWindow) OR 
  4609.        ((containerClass <> typeNull) AND (containerClass <> typeMyAppl)) OR
  4610.        NOT ((form = formName) OR (form = formAbsolutePosition)) THEN
  4611.     BEGIN
  4612.             WindowFromNullAccessor:=errAEWrongDataType;
  4613.             Exit(WindowFromNullAccessor);
  4614.         END;
  4615.     
  4616.   IF (form = formName) THEN
  4617.         BEGIN
  4618.             myErr     := GetPStringFromDescriptor(selectionData, nameStr);
  4619.             theWindow := WindowNameToWindowPtr(@nameStr);
  4620.         END;
  4621.     
  4622.   IF (form = formAbsolutePosition) THEN
  4623.     BEGIN
  4624.         myErr         := GetIntegerFromDescriptor(selectionData, index);
  4625.           theWindow := GetWindowPtrOfNthWindow(index);
  4626.         END;
  4627.       
  4628.     IF (myErr = noErr) THEN
  4629.         myErr := AECreateDesc(typeMyWndw,@theWindow,SizeOf(theWindow),value);
  4630.           
  4631.   WindowFromNullAccessor := myErr;
  4632. END;    { WindowFromNullAccessor }
  4633.  
  4634. FUNCTION ApplicationFromNullAccessor(wantClass            : DescType;
  4635.                                                                          container            : AEDesc;
  4636.                                                                          containerClass : DescType;
  4637.                                                                          form                      : DescType; 
  4638.                                                                          selectionData    : AEDesc;
  4639.                                                                          VAR value            : AEDesc;
  4640.                                                                          theRefCon            : LongInt):  OSErr;
  4641.  
  4642. VAR myErr                :    OSErr;
  4643.         actSize            :    Size;
  4644.         nameStr            :    Str255;
  4645.         theApp          :    appToken;
  4646.         index                :    INTEGER;
  4647.         resultDesc     : AEDesc;
  4648.         
  4649. BEGIN
  4650.   value.dataHandle      := nil;
  4651.     resultDesc.dataHandle := nil;
  4652.   
  4653.   { 
  4654.         should only be called with wantClass = cWindow and
  4655.       with containerClass = typeNull.
  4656.         Currently accept as either formName or formAbsolutePosition
  4657.     }
  4658.     
  4659.   IF (wantClass <> cApplication) OR (containerClass <> typeNull) OR
  4660.        NOT ((form = formName) OR (form = formAbsolutePosition)) THEN
  4661.     BEGIN
  4662.             ApplicationFromNullAccessor:=errAEWrongDataType;
  4663.             Exit(ApplicationFromNullAccessor);
  4664.         END;
  4665.     
  4666.   IF (form = formName) OR (form = formAbsolutePosition) THEN
  4667.         BEGIN
  4668.             (*     Don't care about data how specified - it's this app *)
  4669.             theApp.highLongOfPSN := 0;
  4670.             theApp.lowLongOfPSN  := kCurrentProcess;
  4671.         END;
  4672.       
  4673.     myErr := AECreateDesc(typeMyAppl,@theApp,SizeOf(theApp),value);
  4674.           
  4675.   ApplicationFromNullAccessor := myErr;
  4676. END;    { ApplicationFromNullAccessor}
  4677.  
  4678. PROCEDURE MoveToNonSpace(VAR start:INTEGER; limit:INTEGER; myChars:CharsHandle);
  4679.     (*
  4680.         Treats space,comma, full stop, ; and : as space chars
  4681.     *)
  4682.     BEGIN
  4683.         WHILE (start<=limit) DO
  4684.             IF myChars^^[start] IN [' ',',','.',';',':',CHR(10),CHR(13)] THEN
  4685.                 start := start+1
  4686.             ELSE
  4687.                 Exit(MoveToNonSpace);
  4688.     END;
  4689.     
  4690. PROCEDURE MoveToSpace(VAR start:INTEGER; limit:INTEGER; myChars:CharsHandle);
  4691.     (*
  4692.         Treats space,comma, full stop, ; and : as space chars
  4693.     *)
  4694.     BEGIN
  4695.         WHILE (start<=limit) DO
  4696.             IF NOT (myChars^^[start] IN [' ',',','.',';',':',CHR(10),CHR(13)]) THEN
  4697.                 start := start+1
  4698.             ELSE
  4699.                 Exit(MoveToSpace);
  4700.     END;
  4701.  
  4702. FUNCTION CountWords(inTextHandle:TEHandle; startAt:INTEGER; forHowManyChars:INTEGER):INTEGER;
  4703.     VAR myChars : CharsHandle;
  4704.             start   : INTEGER;
  4705.             limit   : INTEGER;
  4706.             myWords : INTEGER;
  4707.             
  4708.     BEGIN
  4709.         myChars := CharsHandle(inTextHandle^^.hText);
  4710.         limit   := startAt+forHowManyChars-1;
  4711.         start   := startAt;
  4712.         myWords := 0;
  4713.         MoveToNonSpace(start, limit, myChars);
  4714.         WHILE (start<=limit) DO
  4715.             BEGIN
  4716.                 myWords := myWords+1;
  4717.                 MoveToSpace(start, limit, myChars);
  4718.                 MoveToNonSpace(start, limit, myChars);
  4719.             END;
  4720.         CountWords := myWords;
  4721.     END; (* CountWords *)
  4722.     
  4723. PROCEDURE GetNthWordInfo(whichWord         : INTEGER;
  4724.                                                  inTextHandle      : TEHandle;
  4725.                                                  VAR wordStartChar : INTEGER;
  4726.                                                  VAR wordLength    : INTEGER);
  4727.     (*
  4728.         On entry:    wordStartChar is start of char range to count in
  4729.                             wordLength is number of chars to consider
  4730.                             
  4731.         On Exit : wordStartChar is start of requested word
  4732.                             wordLength is number of chars in word
  4733.     *)
  4734.     VAR myChars : CharsHandle;
  4735.             start   : INTEGER;
  4736.             limit   : INTEGER;
  4737.             
  4738.     BEGIN
  4739.         myChars := CharsHandle(inTextHandle^^.hText);
  4740.         limit   := wordStartChar+wordLength-1;
  4741.         start   := wordStartChar;
  4742.         MoveToNonSpace(start, limit, myChars);
  4743.         WHILE (start<=limit) AND (whichWord>0) DO
  4744.             BEGIN
  4745.                 whichWord     := whichWord-1;
  4746.                 wordStartChar := start;
  4747.                 MoveToSpace(start, limit, myChars);
  4748.                 wordLength    := start-wordStartChar;
  4749.                     
  4750.                 MoveToNonSpace(start, limit, myChars);
  4751.             END;
  4752.     END;(* GetNthWordInfo *)
  4753.  
  4754. PROCEDURE GetWordInfo(whichWord         : INTEGER;
  4755.                                             inTextHandle      : TEHandle;
  4756.                                             VAR wordStartChar : INTEGER;
  4757.                                             VAR wordLength    : INTEGER);
  4758.     (*
  4759.         On entry:    wordStartChar is start of char range to count in
  4760.                             wordLength is number of chars to consider
  4761.                             
  4762.         On Exit : wordStartChar is start of requested word
  4763.                             wordLength is number of chars in word
  4764.     *)
  4765.     VAR noOfWords : INTEGER;
  4766.             
  4767.     BEGIN        
  4768.         noOfWords := CountWords(inTextHandle, wordStartChar, wordLength);
  4769.         
  4770.         IF (whichWord<0) THEN
  4771.             whichWord := noOfWords + whichWord +1;
  4772.             
  4773.         IF (whichWord>noOfWords) THEN
  4774.             BEGIN
  4775.                 wordStartChar := wordStartChar+wordLength;
  4776.                 wordLength    := 0;
  4777.             END
  4778.         ELSE
  4779.             GetNthWordInfo(whichWord, inTextHandle, wordStartChar, wordLength);
  4780.     END;
  4781.     
  4782. FUNCTION CountLines(inTextHandle:TEHandle):INTEGER;
  4783.     BEGIN
  4784.         (*
  4785.             CountLines makes use of info in TERec
  4786.         *)
  4787.         CountLines := inTextHandle^^.nLines;
  4788.     END;
  4789.     
  4790. FUNCTION LineOfOffset(theHTE:TEHandle; charOffset:INTEGER):INTEGER;
  4791.     VAR n : INTEGER;
  4792.     
  4793.     BEGIN
  4794.         n := theHTE^^.nLines;
  4795.         
  4796.         WHILE (theHTE^^.lineStarts[n-1]>charOffset) AND
  4797.                     (n>0) DO
  4798.             n := n-1;
  4799.             
  4800.         LineOfOffset := n;
  4801.         
  4802.     END; (*LineOfOffset*)
  4803.  
  4804. PROCEDURE GetLineInfo(whichLine         : INTEGER;
  4805.                                             inTextHandle      : TEHandle;
  4806.                                             VAR lineStartChar : INTEGER;
  4807.                                             VAR lineLength    : INTEGER);
  4808.     VAR noOfLines   : INTEGER;
  4809.             myChars       : CharsHandle;
  4810.             
  4811.             lineOfStart : INTEGER;
  4812.             lineOfEnd   : INTEGER;
  4813.             
  4814.     BEGIN
  4815.         lineOfStart := LineOfOffset(inTextHandle, lineStartChar);
  4816.         lineOfEnd   := LineOfOffset(inTextHandle, lineStartChar+lineLength-1);
  4817.     
  4818.         myChars := CharsHandle(inTextHandle^^.hText);
  4819.         noOfLines := lineOfEnd - lineOfStart +1;
  4820.         
  4821.         IF (whichLine<0) THEN
  4822.             whichLine := noOfLines + whichLine + 1;
  4823.             
  4824.         noOfLines := CountLines(inTextHandle);
  4825.         whichLine := whichLine + lineOfStart - 1; (* convert offset relative to offset absolute *)
  4826.         
  4827.         (* End of addition *)
  4828.         
  4829.         IF (whichLine<=lineOfEnd) THEN
  4830.             BEGIN
  4831.                 lineStartChar := inTextHandle^^.lineStarts[whichLine-1];
  4832.                 IF (whichLine=noOfLines) THEN
  4833.                     lineLength  := inTextHandle^^.teLength
  4834.                 ELSE
  4835.                     lineLength  := inTextHandle^^.lineStarts[whichLine];
  4836.                 
  4837.                 lineLength    := lineLength-lineStartChar;
  4838.                 (*
  4839.                     Don't return CR
  4840.                 *)
  4841.                 IF (myChars^^[ lineStartChar+lineLength-1] = CHR(13)) THEN
  4842.                     lineLength := lineLength-1;
  4843.             END
  4844.         ELSE
  4845.             BEGIN
  4846.                 IF (whichLine<noOfLines) THEN
  4847.                   lineStartChar := inTextHandle^^.lineStarts[whichLine] (* start of whichLine++ *)
  4848.                 ELSE
  4849.                     lineStartChar := inTextHandle^^.teLength;
  4850.                     
  4851.                 lineLength    := 0;
  4852.             END;
  4853.     END; (* GetLineInfo *)
  4854.     
  4855. FUNCTION TextElemFromWndwAccessor(wantClass            : DescType;
  4856.                                                                     container            : AEDesc ;
  4857.                                                                     containerClass: DescType;
  4858.                                                                     form                    : DescType;
  4859.                                                                     selectionData    : AEDesc;
  4860.                                                                     VAR value            : AEDesc;
  4861.                                                                     theRefCon            : LongInt): OSErr;
  4862. VAR 
  4863.     myErr                        :    OSErr;
  4864.     ignoreErr              :    OSErr;
  4865.     theWindow                :    WindowToken;
  4866.     actSize                    :    Size;
  4867.     index                        :    LongInt;
  4868.     theTextToken        : TextToken;
  4869.     selectionRecord    :    AERecord;
  4870.     startText                : TextToken;
  4871.     stopText                :    TextToken;
  4872.     returnedType        : DescType;
  4873.     windDesc        : AEDesc;
  4874.     theHTE                    : TEHandle;
  4875.     theDocument     : DPtr;
  4876.     wordStartChar   : INTEGER;
  4877.     wordLength      : INTEGER;
  4878.     
  4879. BEGIN
  4880.   myErr := -1700;    { or whatever }
  4881.     
  4882.     selectionRecord.dataHandle := NIL;
  4883.   
  4884.   { do some checking for robustness' sake }
  4885.   
  4886.   IF (containerClass <> cWindow) OR
  4887.        ((wantClass <> cChar) AND 
  4888.              (wantClass <> cSpot) AND 
  4889.             (wantClass <> cWord) AND
  4890.             (wantClass <> cLine)    ) OR
  4891.          ((form<>formRange) AND (form<>formAbsolutePosition)) THEN
  4892.     BEGIN
  4893.           TextElemFromWndwAccessor := errAEWrongDataType;
  4894.             Exit(TextElemFromWndwAccessor);
  4895.         END;
  4896.         
  4897.   { let's get the window which contains the text element }
  4898.     
  4899.     myErr := AECoerceDesc(container, typeMyWndw, windDesc);
  4900.     GetRawDataFromDescriptor(    windDesc,
  4901.                                                         @theWindow,
  4902.                                                         sizeOf(theWindow),
  4903.                                                         actSize);
  4904.     myErr := AEDisposeDesc(windDesc);
  4905.                                                         
  4906.     IF (theWindow=NIL) THEN
  4907.         myErr := errAEIllegalIndex
  4908.     ELSE
  4909.         BEGIN
  4910.                                                                                 
  4911.             theTextToken.tokenWindow := theWindow;
  4912.             
  4913.             theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  4914.             theHTE      := theDocument^.theText;
  4915.             
  4916.             IF (form = formAbsolutePosition) THEN
  4917.                 BEGIN
  4918.                     myErr := GetLongIntFromDescriptor(selectionData, index);
  4919.                     
  4920.                     IF (wantClass=cSpot) THEN
  4921.                         BEGIN
  4922.                             IF (index<0) THEN
  4923.                                 theTextToken.tokenOffset := theHTE^^.teLength+index+2 (* Past last char *)
  4924.                             ELSE
  4925.                                 theTextToken.tokenOffset := index;
  4926.                                 
  4927.                             theTextToken.tokenLength := 0;
  4928.                         END;
  4929.                         
  4930.                     IF (wantClass=cChar) THEN
  4931.                         BEGIN
  4932.                             IF (index<0) THEN
  4933.                                 theTextToken.tokenOffset := theHTE^^.teLength+index+1
  4934.                             ELSE
  4935.                                 theTextToken.tokenOffset := index;
  4936.                             
  4937.                             theTextToken.tokenLength := 1;
  4938.                         END;
  4939.                     
  4940.                     IF (wantClass=cWord) THEN
  4941.                         BEGIN
  4942.                             wordStartChar := 0;
  4943.                             wordLength    := theHTE^^.teLength;
  4944.                             GetWordInfo(index, theHTE, wordStartChar, wordLength); (* zero based *)
  4945.                             theTextToken.tokenOffset := wordStartChar+1;
  4946.                             theTextToken.tokenLength := wordLength;
  4947.                         END;
  4948.                         
  4949.                     IF (wantClass=cLine) THEN
  4950.                         BEGIN
  4951.                             wordStartChar := 0;
  4952.                             wordLength    := theHTE^^.teLength;
  4953.                             GetLineInfo(index, theHTE, wordStartChar, wordLength); (* zero based *)
  4954.                             theTextToken.tokenOffset := wordStartChar+1;
  4955.                             theTextToken.tokenLength := wordLength;
  4956.                         END;
  4957.                 END;    { of formAbsolutePosition }
  4958.             
  4959.             IF form = formRange THEN
  4960.                 BEGIN
  4961.                     { coerce the selection data into an AERecord }
  4962.                     
  4963.                      myErr := AECoerceDesc(selectionData,typeAERecord,selectionRecord);
  4964.                     
  4965.                     { get the start object as a text token - 
  4966.                             this will reenter this proc but as formAbsolutePosition via the coercion handler}
  4967.                     
  4968.                     myErr :=  AEGetKeyPtr(selectionRecord,
  4969.                                                                 keyAERangeStart,
  4970.                                                                 typeMyText,
  4971.                                                                 returnedType,
  4972.                                                                 @startText,
  4973.                                                                 SizeOf(startText),
  4974.                                                                 actSize);
  4975.                     
  4976.                     { now do the same for the stop object }
  4977.                     
  4978.                     IF (myErr=noErr) THEN
  4979.                         myErr :=  AEGetKeyPtr(selectionRecord,
  4980.                                                                     keyAERangeStop,
  4981.                                                                     typeMyText,
  4982.                                                                     returnedType,
  4983.                                                                     @stopText,
  4984.                                                                     SizeOf(stopText),
  4985.                                                                     actSize);
  4986.                     
  4987.                     IF (myErr=noErr) THEN
  4988.                         IF (theTextToken.tokenWindow <> stopText.tokenWindow) OR
  4989.                              (theTextToken.tokenWindow <> startText.tokenWindow) THEN
  4990.                             BEGIN
  4991.                                 myErr := errAECorruptData;    { or whatever }
  4992.                             END;
  4993.                         
  4994.                     theTextToken.tokenOffset  := startText.tokenOffset;            
  4995.                     theTextToken.tokenLength  := stopText.tokenOffset +
  4996.                                                                              stopText.tokenLength - 
  4997.                                                                              startText.tokenOffset;
  4998.                                                                              
  4999.                     IF (theTextToken.tokenLength<0) THEN
  5000.                         myErr := errAECorruptData;    { or whatever }
  5001.                                                                          
  5002.                     IF AEDisposeDesc(selectionRecord)=noErr THEN;
  5003.                     
  5004.                 END;    { of formRange }
  5005.         END;
  5006.     
  5007.     { return theTextToken in a descriptor }
  5008.     
  5009.     IF (myErr=noErr) THEN
  5010.         myErr := AECreateDesc(typeMyText,
  5011.                                                     @theTextToken,
  5012.                                                     SizeOf(theTextToken),
  5013.                                                     value);
  5014.             
  5015.   TextElemFromWndwAccessor := myErr;
  5016. END;    { TextElemFromWndwAccessor }
  5017.  
  5018. FUNCTION TextElemFromTextAccessor(wantClass            : DescType;
  5019.                                                                     container            : AEDesc;
  5020.                                                                     containerClass: DescType;
  5021.                                                                     form                    : DescType;
  5022.                                                                     selectionData    : AEDesc;
  5023.                                                                     VAR value            : AEDesc;
  5024.                                                                     theRefCon            : LongInt): OSErr;
  5025. VAR 
  5026.     myErr                        :    OSErr;
  5027.     actSize                    :    Size;
  5028.     index                        :    LongInt;
  5029.     theTextToken        : TextToken;
  5030.     selectionRecord    :    AERecord;
  5031.     startText                : TextToken;
  5032.     stopText                :    TextToken;
  5033.     returnedType        : DescType;
  5034.     textDesc        : AEDesc;
  5035.     theHTE                    : TEHandle;
  5036.     wordStartChar   : INTEGER;
  5037.     wordLength      : INTEGER;
  5038.     theDocument     : DPtr;
  5039.  
  5040. BEGIN
  5041.   myErr := -1700;    { or whatever }
  5042.       
  5043.   { do some checking for robustness' sake }
  5044.     
  5045.   IF ((wantClass <> cChar) AND 
  5046.         (wantClass <> cSpot) AND 
  5047.         (wantClass <> cLine) AND 
  5048.             (wantClass <> cWord)) OR
  5049.        ((form <> formAbsolutePosition) AND (form <> formRange)) THEN
  5050.     BEGIN
  5051.             TextElemFromTextAccessor := errAEWrongDataType;
  5052.             Exit(TextElemFromTextAccessor);
  5053.         END;
  5054.     
  5055.   { let's get the src text }
  5056.     myErr := AECoerceDesc(container, typeMyText, textDesc);
  5057.     GetRawDataFromDescriptor(    textDesc,
  5058.                                                         @theTextToken,
  5059.                                                         sizeOf(theTextToken),
  5060.                                                         actSize);
  5061.                                                         
  5062.     myErr := AEDisposeDesc(textDesc);
  5063.                                                         
  5064.     theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  5065.     theHTE      := theDocument^.theText;
  5066.     
  5067.   IF (form = formAbsolutePosition) THEN
  5068.     BEGIN
  5069.             myErr := GetLongIntFromDescriptor(selectionData, index);
  5070.             
  5071.             IF (wantClass=cSpot) THEN
  5072.               BEGIN
  5073.                     IF (index<0) THEN
  5074.                         theTextToken.tokenOffset := theTextToken.tokenOffset+index + 1 + theTextToken.tokenLength
  5075.                     ELSE
  5076.                         theTextToken.tokenOffset := theTextToken.tokenOffset+index-1;
  5077.                     theTextToken.tokenLength := 0;
  5078.                 END;
  5079.                 
  5080.             IF (wantClass=cChar) THEN
  5081.                 BEGIN
  5082.                     IF (index<0) THEN
  5083.                         theTextToken.tokenOffset := theTextToken.tokenOffset+index + 1+theTextToken.tokenLength
  5084.                     ELSE
  5085.                         theTextToken.tokenOffset := theTextToken.tokenOffset+index-1;
  5086.                     theTextToken.tokenLength := 1;
  5087.                 END;
  5088.                                 
  5089.             IF (wantClass=cWord) THEN
  5090.                 BEGIN
  5091.                     wordStartChar := theTextToken.tokenOffset-1;
  5092.                     wordLength    := theTextToken.tokenLength;
  5093.                     
  5094.                     GetWordInfo(index, theHTE, wordStartChar, wordLength);(*zero based*)
  5095.                     
  5096.                     theTextToken.tokenOffset := wordStartChar+1;
  5097.                     theTextToken.tokenLength := wordLength;
  5098.                 END;
  5099.                 
  5100.             IF (wantClass=cLine) THEN
  5101.                 BEGIN
  5102.                     wordStartChar := theTextToken.tokenOffset-1;
  5103.                     wordLength    := theTextToken.tokenLength;
  5104.                     
  5105.                     GetLineInfo(index, theHTE, wordStartChar, wordLength);
  5106.                     
  5107.                     theTextToken.tokenOffset := wordStartChar+1;
  5108.                     theTextToken.tokenLength := wordLength;
  5109.                 END;
  5110.  
  5111.         END;    { of formAbsolutePosition }
  5112.     
  5113.   
  5114.   IF (form = formRange) THEN
  5115.     BEGIN
  5116.           { coerce the selection data into an AERecord }
  5117.             
  5118.               myErr := AECoerceDesc(selectionData,typeAERecord,selectionRecord);
  5119.           
  5120.           { get the start object as a text token - 
  5121.                     this will reenter this proc but as formAbsolutePosition via the coercion handler}
  5122.           
  5123.             myErr :=  AEGetKeyPtr(selectionRecord,
  5124.                                                         keyAERangeStart,
  5125.                                                         typeMyText,
  5126.                                                         returnedType,
  5127.                                                   @startText,
  5128.                                                         SizeOf(startText),
  5129.                                                         actSize);
  5130.           
  5131.           { now do the same for the stop object }
  5132.             
  5133.             IF (myErr=noErr) THEN
  5134.                 myErr :=  AEGetKeyPtr(selectionRecord,
  5135.                                                             keyAERangeStop,
  5136.                                                             typeMyText,
  5137.                                                             returnedType,
  5138.                                                             @stopText,
  5139.                                                             SizeOf(stopText),
  5140.                                                             actSize);
  5141.           
  5142.             IF (myErr=noErr) THEN
  5143.                 IF (theTextToken.tokenWindow <> stopText.tokenWindow) OR
  5144.                      (theTextToken.tokenWindow <> startText.tokenWindow) THEN
  5145.                     BEGIN
  5146.                         myErr := errAECorruptData;    { or whatever }
  5147.                     END;
  5148.                 
  5149.             theTextToken.tokenOffset  := startText.tokenOffset;            
  5150.           theTextToken.tokenLength  := stopText.tokenOffset +
  5151.                                                                    stopText.tokenLength - 
  5152.                                                                    startText.tokenOffset;
  5153.                                                                  
  5154.             myErr := AEDisposeDesc(selectionRecord);
  5155.         END;    { of formRange }
  5156.         
  5157.     { return theTextToken in a descriptor }
  5158.     
  5159.     myErr := AECreateDesc(typeMyText,
  5160.                                                 @theTextToken,
  5161.                                                 SizeOf(theTextToken),
  5162.                                                 value);
  5163.     
  5164.   TextElemFromTextAccessor := myErr;
  5165. END;    { TextElemFromTextAccessor }
  5166.  
  5167. FUNCTION PropertyFromTextAccessor(wantClass                : DescType;
  5168.                                                                     container                : AEDesc ;
  5169.                                                                     containerClass    : DescType;
  5170.                                                                     form                        : DescType; 
  5171.                                                                     selectionData        : AEDesc;
  5172.                                                                     VAR value                : AEDesc;
  5173.                                                                     theRefCon                : LongInt): OSErr;
  5174. VAR 
  5175.         myErr                    : OSErr;
  5176.         theTextToken    : TextToken;
  5177.         theProperty        : DescType;
  5178.         textDesc        : AEDesc;
  5179.         propDesc      : AEDesc;
  5180.         actualSize    : Size;
  5181.         myTextProp    : TextPropToken;
  5182.         
  5183. BEGIN
  5184.     value.dataHandle    := nil;
  5185.     textDesc.dataHandle := nil;
  5186.     propDesc.dataHandle := nil;
  5187.   
  5188.   IF (wantClass <> cProperty) OR
  5189.        (form <> formPropertyID) THEN
  5190.     BEGIN
  5191.             PropertyFromTextAccessor:=errAEWrongDataType;
  5192.             Exit(PropertyFromTextAccessor);
  5193.         END;
  5194.     
  5195.   { get the text token }
  5196.   myErr := AECoerceDesc(container, typeMyText, textDesc);
  5197.     GetRawDataFromDescriptor(    textDesc,
  5198.                                                         @theTextToken,
  5199.                                                         sizeOf(theTextToken),
  5200.                                                         actualSize);
  5201.           
  5202.   { get the property }
  5203.   myErr := AECoerceDesc(selectionData, typeType, propDesc);
  5204.     GetRawDataFromDescriptor(    propDesc,
  5205.                                                         @theProperty,
  5206.                                                         sizeOf(theProperty),
  5207.                                                         actualSize);
  5208.     (*
  5209.         Combine the two into single token
  5210.     *)
  5211.     myTextProp.propertyTextToken := theTextToken;
  5212.     myTextProp.propertyProperty  := theProperty;
  5213.     
  5214.   myErr := AECreateDesc(typeMyTextProp,
  5215.                                                 @myTextProp,
  5216.                                                 SizeOf(myTextProp),
  5217.                                                 value);
  5218.       
  5219.     IF (textDesc.dataHandle<>nil) THEN
  5220.         DisposHandle(Handle(textDesc.dataHandle));
  5221.         
  5222.     IF (propDesc.dataHandle<>nil) THEN
  5223.         DisposHandle(Handle(propDesc.dataHandle));
  5224.         
  5225.   PropertyFromTextAccessor := myErr;
  5226. END;    { PropertyFromTextAccessor }
  5227.  
  5228. FUNCTION PropertyFromWndwAccessor(wantClass                : DescType;
  5229.                                                                     container                : AEDesc ;
  5230.                                                                     containerClass    : DescType;
  5231.                                                                     form                        : DescType; 
  5232.                                                                     selectionData        : AEDesc;
  5233.                                                                     VAR value                : AEDesc;
  5234.                                                                     theRefCon                : LongInt): OSErr;
  5235. VAR 
  5236.         myErr                    : OSErr;
  5237.         theWindowToken: WindowToken;
  5238.         theProperty        : DescType;
  5239.         windowDesc    : AEDesc;
  5240.         propDesc      : AEDesc;
  5241.         actualSize    : Size;
  5242.         myWindowProp  : WindowPropToken;
  5243.         
  5244. BEGIN
  5245.     value.dataHandle      := nil;
  5246.     windowDesc.dataHandle := nil;
  5247.     propDesc.dataHandle   := nil;
  5248.   
  5249.   IF (wantClass <> cProperty) OR
  5250.        (form <> formPropertyID) THEN
  5251.     BEGIN
  5252.             PropertyFromWndwAccessor:=errAEWrongDataType;
  5253.             Exit(PropertyFromWndwAccessor);
  5254.         END;
  5255.     
  5256.   { get the window token - it's the container }
  5257.     
  5258.   myErr := AECoerceDesc(container, typeMyWndw, windowDesc);
  5259.     GetRawDataFromDescriptor(    windowDesc,
  5260.                                                         @theWindowToken,
  5261.                                                         sizeOf(theWindowToken),
  5262.                                                         actualSize);
  5263.                                                         
  5264.     { Check the window exists }
  5265.     
  5266.   IF (theWindowToken=NIL) THEN
  5267.         myErr := errAEIllegalIndex
  5268.     ELSE
  5269.         BEGIN
  5270.         
  5271.             { get the property - it's in the selection data }
  5272.             
  5273.             myErr := AECoerceDesc(selectionData, typeType, propDesc);
  5274.             GetRawDataFromDescriptor(    propDesc,
  5275.                                                                 @theProperty,
  5276.                                                                 sizeOf(theProperty),
  5277.                                                                 actualSize);
  5278.             (*
  5279.                 Combine the two into single token
  5280.             *)
  5281.             myWindowProp.tokenWindowToken := theWindowToken;
  5282.             myWindowProp.tokenProperty    := theProperty;
  5283.             
  5284.             myErr := AECreateDesc(typeMyWindowProp,
  5285.                                                         @myWindowProp,
  5286.                                                         SizeOf(myWindowProp),
  5287.                                                         value);
  5288.         END;
  5289.       
  5290.     IF (windowDesc.dataHandle<>nil) THEN
  5291.         DisposHandle(Handle(windowDesc.dataHandle));
  5292.         
  5293.     IF (propDesc.dataHandle<>nil) THEN
  5294.         DisposHandle(Handle(propDesc.dataHandle));
  5295.         
  5296.   PropertyFromWndwAccessor := myErr;
  5297. END;    { PropertyFromWndwAccessor }
  5298.  
  5299. FUNCTION PropertyFromApplAccessor(wantClass                : DescType;
  5300.                                                                     container                : AEDesc ;
  5301.                                                                     containerClass    : DescType;
  5302.                                                                     form                        : DescType; 
  5303.                                                                     selectionData        : AEDesc;
  5304.                                                                     VAR value                : AEDesc;
  5305.                                                                     theRefCon                : LongInt): OSErr;
  5306. VAR 
  5307.         myErr                    : OSErr;
  5308.         theApplToken  : AppToken;
  5309.         theProperty        : DescType;
  5310.         applDesc      : AEDesc;
  5311.         propDesc      : AEDesc;
  5312.         actualSize    : Size;
  5313.         myApplProp    : ApplPropToken;
  5314.         
  5315. BEGIN
  5316.     value.dataHandle      := nil;
  5317.     applDesc.dataHandle   := nil;
  5318.     propDesc.dataHandle   := nil;
  5319.   
  5320.   IF (wantClass <> cProperty) OR
  5321.        (form <> formPropertyID) THEN
  5322.     BEGIN
  5323.             PropertyFromApplAccessor:=errAEWrongDataType;
  5324.             Exit(PropertyFromApplAccessor);
  5325.         END;
  5326.     
  5327.   { get the application token - it's the container }
  5328.     
  5329.   myErr := AECoerceDesc(container, typeMyAppl, applDesc);
  5330.     GetRawDataFromDescriptor(    applDesc,
  5331.                                                         @theApplToken,
  5332.                                                         sizeOf(theApplToken),
  5333.                                                         actualSize);
  5334.           
  5335.   { get the property - it's in the selection data }
  5336.     
  5337.   myErr := AECoerceDesc(selectionData, typeType, propDesc);
  5338.     GetRawDataFromDescriptor(    propDesc,
  5339.                                                         @theProperty,
  5340.                                                         sizeOf(theProperty),
  5341.                                                         actualSize);
  5342.     (*
  5343.         Combine the two into single token
  5344.     *)
  5345.     myApplProp.tokenApplToken    := theApplToken;
  5346.     myApplProp.tokenApplProperty := theProperty;
  5347.     
  5348.   myErr := AECreateDesc(typeMyApplProp,
  5349.                                                 @myApplProp,
  5350.                                                 SizeOf(myApplProp),
  5351.                                                 value);
  5352.       
  5353.     IF (applDesc.dataHandle<>nil) THEN
  5354.         DisposHandle(Handle(applDesc.dataHandle));
  5355.         
  5356.     IF (propDesc.dataHandle<>nil) THEN
  5357.         DisposHandle(Handle(propDesc.dataHandle));
  5358.         
  5359.   PropertyFromApplAccessor := myErr;
  5360. END;    { PropertyFromApplAccessor }
  5361.  
  5362. FUNCTION MenuNameToMenuToken(theName:Str255;VAR theToken:MenuToken):OSErr;
  5363.     VAR
  5364.         index : INTEGER;
  5365.         
  5366.     BEGIN
  5367.         for index := appleM TO kLastMenu DO
  5368.           BEGIN
  5369.                 IF (IUEqualString(theName, myMenus[index]^^.menuData)=0) THEN
  5370.                   BEGIN
  5371.                         theToken.theTokenMenu := myMenus[index];
  5372.                         theToken.theTokenID   := index+appleID;
  5373.                         
  5374.                         MenuNameToMenuToken := noErr;
  5375.                         Exit(MenuNameToMenuToken);
  5376.                     END;
  5377.           END;
  5378.         MenuNameToMenuToken := errAEIllegalIndex;
  5379.     END;
  5380.  
  5381. FUNCTION MenuFromNullAccessor(wantClass     : DescType;
  5382.                                                             container     : AEDesc;
  5383.                                                             containerClass: DescType;
  5384.                                                             form          : DescType; 
  5385.                                                             selectionData : AEDesc;
  5386.                                                             VAR value     : AEDesc;
  5387.                                                             theRefCon     : LONGINT):OSErr;
  5388.     VAR    
  5389.         myErr      : OSErr;
  5390.         nameStr    : Str255;
  5391.         theMenu    : MenuToken;
  5392.         index      : INTEGER;
  5393.         resultDesc : AEDesc;
  5394.         
  5395.   BEGIN        
  5396.         myErr := errAEBadKeyForm;    (* or whatever *)
  5397.         
  5398.         value.dataHandle      := nil;
  5399.         resultDesc.dataHandle := nil;
  5400.         
  5401.         (* 
  5402.             should only be called with wantClass = cMenu and
  5403.             with containerClass = typeNull or typeMyAppl.
  5404.             Currently accept as either formName or formAbsolutePosition
  5405.         *)
  5406.         
  5407.         if ((wantClass <> cMenu) OR 
  5408.               ((containerClass <> typeNull) AND (containerClass <> typeMyAppl)) OR
  5409.                NOT((form = formName) OR (form = formAbsolutePosition))) THEN
  5410.             MenuFromNullAccessor:= errAEWrongDataType;
  5411.         
  5412.         IF (form = formName) THEN
  5413.             BEGIN
  5414.                 myErr := GetPStringFromDescriptor(selectionData, nameStr);
  5415.                 myErr := MenuNameToMenuToken(nameStr, theMenu);
  5416.             END;
  5417.         
  5418.         IF (form = formAbsolutePosition) THEN
  5419.             BEGIN
  5420.                 myErr     := GetIntegerFromDescriptor(selectionData, index);
  5421.                 IF (index<0) THEN
  5422.                     index := kLastMenu + index + 1;
  5423.                     
  5424.                 IF (index>0) AND (index<=kLastMenu+1) THEN
  5425.                     BEGIN
  5426.                         theMenu.theTokenMenu := myMenus[index-1];
  5427.                         theMenu.theTokenID   := index-1+appleID;
  5428.                     END
  5429.                 else
  5430.               myErr := errAEIllegalIndex;    (* or whatever *)
  5431.             END;
  5432.             
  5433.         IF (myErr = noErr) THEN
  5434.             myErr := AECreateDesc(typeMyMenu, Ptr(@theMenu), sizeof(theMenu), value);
  5435.                 
  5436.         MenuFromNullAccessor := myErr;
  5437.     END;    (* MenuFromNullAccessor *)
  5438.  
  5439. FUNCTION PropertyFromMenuAccessor(wantClass      : DescType;
  5440.                                                                     container      : AEDesc;
  5441.                                                                     containerClass : DescType;
  5442.                                                                     form           : DescType;
  5443.                                                                     selectionData  : AEDesc;
  5444.                                                                     VAR value      : AEDesc;
  5445.                                                                     theRefCon      : LONGINT) : OSErr;
  5446.   VAR
  5447.         myErr       : OSErr;
  5448.         ignoreErr   : OSErr;
  5449.         theMenuToken: MenuToken;
  5450.         theProperty : DescType;
  5451.         menuDesc    : AEDesc;
  5452.         propDesc    : AEDesc;
  5453.         actualSize  : Size;
  5454.         myMenuProp  : MenuPropToken;
  5455.             
  5456.     BEGIN
  5457.         value.dataHandle     := nil;
  5458.         menuDesc.dataHandle  := nil;
  5459.         propDesc.dataHandle  := nil;
  5460.         
  5461.         IF ((wantClass <> cProperty) OR
  5462.               (form <> formPropertyID)) THEN
  5463.             BEGIN
  5464.                 PropertyFromMenuAccessor := errAEWrongDataType;
  5465.                 Exit(PropertyFromMenuAccessor);
  5466.             END;
  5467.         
  5468.         (* get the menu token - it's the container *)
  5469.         
  5470.         myErr := AECoerceDesc(container, typeMyMenu, menuDesc);
  5471.         GetRawDataFromDescriptor(menuDesc,
  5472.                                                          Ptr(@theMenuToken),
  5473.                                                          sizeof(theMenuToken),
  5474.                                                          actualSize);
  5475.                 
  5476.         (* get the property - it's in the selection data *)
  5477.         
  5478.         myErr := AECoerceDesc(selectionData, typeType, propDesc);
  5479.         GetRawDataFromDescriptor(propDesc,
  5480.                                                          Ptr(@theProperty),
  5481.                                                          sizeof(theProperty),
  5482.                                                          actualSize);
  5483.         (*
  5484.             Combine the two into single token
  5485.         *)
  5486.         myMenuProp.theMenuToken := theMenuToken;
  5487.         myMenuProp.theMenuProp  := theProperty;
  5488.         
  5489.         myErr := AECreateDesc(typeMyMenuProp,
  5490.                                                   Ptr(@myMenuProp),
  5491.                                                   sizeof(myMenuProp),
  5492.                                                   value);
  5493.             
  5494.         IF (menuDesc.dataHandle<>nil) THEN
  5495.             ignoreErr := AEDisposeDesc(menuDesc);
  5496.             
  5497.         IF (propDesc.dataHandle<>nil) THEN
  5498.             ignoreErr := AEDisposeDesc(propDesc);
  5499.             
  5500.         PropertyFromMenuAccessor := myErr;
  5501. END;    (* PropertyFromMenuAccessor *)
  5502.  
  5503. FUNCTION PropertyFromMenuItemAccessor(wantClass             : DescType;
  5504.                                                                             container             : AEDesc;
  5505.                                                                             containerClass  : DescType;
  5506.                                                                             form            : DescType; 
  5507.                                                                             selectionData   :    AEDesc;
  5508.                                                                             VAR value       :    AEDesc;
  5509.                                                                             theRefCon       : longint):OSErr;
  5510.     VAR    
  5511.         myErr            : OSErr;
  5512.         ignoreErr        : OSErr;
  5513.         theMenuItemToken : MenuItemToken;
  5514.         theProperty      : DescType;
  5515.         itemDesc         : AEDesc;
  5516.         propDesc         : AEDesc;
  5517.         actualSize       : Size;
  5518.         myItemProp       : MenuItemPropToken;
  5519.             
  5520.     BEGIN
  5521.         value.dataHandle     := nil;
  5522.         itemDesc.dataHandle  := nil;
  5523.         propDesc.dataHandle  := nil;
  5524.         
  5525.         if ((wantClass <> cProperty) OR
  5526.               (form <> formPropertyID)) THEN
  5527.             BEGIN
  5528.                 PropertyFromMenuItemAccessor := errAEWrongDataType;
  5529.             END;
  5530.         
  5531.         (* get the menu token - it's the container *)
  5532.         
  5533.         myErr := AECoerceDesc(container, typeMyMenuItem, itemDesc);
  5534.         GetRawDataFromDescriptor(itemDesc,
  5535.                                                          Ptr(@theMenuItemToken),
  5536.                                                          sizeof(theMenuItemToken),
  5537.                                                          actualSize);
  5538.                 
  5539.         (* get the property - it's in the selection data *)
  5540.         
  5541.         myErr := AECoerceDesc(selectionData, typeType, propDesc);
  5542.         GetRawDataFromDescriptor(propDesc,
  5543.                                                          Ptr(@theProperty),
  5544.                                                          sizeof(theProperty),
  5545.                                                          actualSize);
  5546.         (*
  5547.             Combine the two into single token
  5548.         *)
  5549.         myItemProp.theItemToken  := theMenuItemToken;
  5550.         myItemProp.theItemProp   := theProperty;
  5551.         
  5552.         myErr := AECreateDesc(typeMyItemProp,
  5553.                                                   Ptr(@myItemProp),
  5554.                                                   sizeof(myItemProp),
  5555.                                                   value);
  5556.             
  5557.         IF (itemDesc.dataHandle<>NIL) THEN
  5558.             ignoreErr := AEDisposeDesc(itemDesc);
  5559.             
  5560.         IF (propDesc.dataHandle<>NIL) THEN
  5561.             ignoreErr := AEDisposeDesc(propDesc);
  5562.             
  5563.         PropertyFromMenuItemAccessor := myErr;
  5564. END;    (* PropertyFromMenuItemAccessor *)
  5565.  
  5566. FUNCTION ItemNameToItemIndex(theName:Str255; theMenu:MenuHandle; VAR theIndex: INTEGER):OSErr;
  5567.     VAR
  5568.         index    : INTEGER;
  5569.         maxItems : INTEGER;
  5570.         menuName : Str255;
  5571.         
  5572.     BEGIN
  5573.         maxItems := CountMItems(theMenu);
  5574.         
  5575.         FOR index := 1 TO maxItems DO
  5576.             BEGIN
  5577.                 GetItem(theMenu, index, menuName);
  5578.                 IF (IUEqualString(theName, menuName)=0) THEN
  5579.                     BEGIN
  5580.                         theIndex := index;
  5581.                         ItemNameToItemIndex := noErr;
  5582.                         Exit(ItemNameToItemIndex);
  5583.                     END;
  5584.             END;
  5585.         ItemNameToItemIndex := errAEIllegalIndex;
  5586.     END;
  5587.     
  5588. FUNCTION MenuItemFromMenuAccessor(wantClass             : DescType;
  5589.                                                                     container             : AEDesc;
  5590.                                                                     containerClass  : DescType;
  5591.                                                                     form            : DescType; 
  5592.                                                                     selectionData   :    AEDesc;
  5593.                                                                     VAR value       :    AEDesc;
  5594.                                                                     theRefCon       : longint) : OSErr;
  5595.   VAR
  5596.         myErr                 : OSErr;
  5597.         ignoreErr             : OSErr;
  5598.         theMenuItemToken : MenuItemToken;
  5599.         theMenuToken     : MenuToken;
  5600.         menuDesc         : AEDesc;
  5601.         actualSize       : Size;
  5602.         nameStr          : Str255;
  5603.         maxItems         : INTEGER;
  5604.         index            : INTEGER;
  5605.             
  5606.     BEGIN
  5607.         value.dataHandle     := nil;
  5608.         menuDesc.dataHandle  := nil;
  5609.         
  5610.         IF ((wantClass <> cMenuItem) OR
  5611.             (containerClass <> cMenu) OR
  5612.               ((form <> formAbsolutePosition) AND (form <> formName))) THEN
  5613.             BEGIN
  5614.                 MenuItemFromMenuAccessor := errAEWrongDataType;
  5615.                 Exit(MenuItemFromMenuAccessor);
  5616.             END;
  5617.         
  5618.         (* get the menu token - it's the container *)
  5619.         
  5620.         myErr := AECoerceDesc(container, typeMyMenu, menuDesc);
  5621.         GetRawDataFromDescriptor(menuDesc,
  5622.                                                          Ptr(@theMenuToken),
  5623.                                                          sizeof(theMenuToken),
  5624.                                                          actualSize);
  5625.                 
  5626.         IF (form=formAbsolutePosition) THEN
  5627.             BEGIN
  5628.                 myErr := GetIntegerFromDescriptor(selectionData, index);
  5629.                 maxItems := CountMItems(theMenuToken.theTokenMenu);
  5630.                 
  5631.                 IF (index<0) THEN
  5632.                     index := maxItems + index + 1;
  5633.                     
  5634.                 IF ((index<1) OR (index>maxItems)) THEN
  5635.                   myErr := errAEIllegalIndex;
  5636.             END;
  5637.             
  5638.         if (form = formName) THEN
  5639.             BEGIN
  5640.                 myErr  := GetPStringFromDescriptor(selectionData, nameStr);
  5641.                 myErr  := ItemNameToItemIndex(nameStr, theMenuToken.theTokenMenu, index);
  5642.             END;
  5643.         
  5644.         (*
  5645.             Combine the two into single token
  5646.         *)
  5647.     
  5648.         theMenuItemToken.theMenuToken  := theMenuToken;
  5649.         theMenuItemToken.theTokenItem  := index;
  5650.         
  5651.         IF (myErr=noErr) THEN
  5652.             myErr := AECreateDesc(typeMyMenuItem,
  5653.                                                       Ptr(@theMenuItemToken),
  5654.                                                       sizeof(theMenuItemToken),
  5655.                                                       value);
  5656.             
  5657.         IF (menuDesc.dataHandle<>NIL) THEN
  5658.             ignoreErr := AEDisposeDesc(menuDesc);
  5659.             
  5660.         MenuItemFromMenuAccessor := myErr;
  5661. END;    (* MenuItemFromMenuAccessor *)
  5662.         
  5663. {*****************************************************************************}
  5664. {
  5665.     Stuff for counting objects
  5666. }
  5667.  
  5668. FUNCTION MyCountProc(    desiredType        : DescType;
  5669.                                             containerClass: DescType;
  5670.                                             container            : AEDesc;
  5671.                                             VAR result        : LongInt): OSErr;
  5672.                                             
  5673. { so far all I count is:
  5674.   (1) the number of active windows in the app;
  5675.   (2) the number of words in a window 
  5676. }
  5677.  
  5678. VAR myErr                        :    OSErr;
  5679.         theWindowToken     : WindowToken;
  5680.         theDocument     : DPtr;
  5681.         theHTE          : TEHandle;
  5682.         newDesc                 : AEDesc;
  5683.         wordStart                : INTEGER;
  5684.         wordLength      : INTEGER;
  5685.         tokenSize                : Size;
  5686.         theTextToken        : TextToken;
  5687.         
  5688. BEGIN
  5689.   result := -1;    { easily recognized illegal value }
  5690.     
  5691.     myErr := errAEWrongDataType;
  5692.     
  5693.     IF (desiredType = cWindow) THEN
  5694.         BEGIN
  5695.             IF (containerClass = typeNull) OR
  5696.                  (containerClass = cApplication) THEN
  5697.                 result := CountWindows;
  5698.         END;
  5699.         
  5700.     IF (desiredType = cWord) OR
  5701.        (desiredType = cLine) OR
  5702.        (desiredType = cChar) THEN
  5703.         BEGIN
  5704.             myErr := AECoerceDesc(container, typeMyWndw, newDesc);
  5705.             IF (newDesc.descriptorType<>typeNull) THEN
  5706.                 BEGIN
  5707.                     GetRawDataFromDescriptor(newDesc,
  5708.                                                                      @theWindowToken,
  5709.                                                                      SizeOf(theWindowToken),
  5710.                                                                      tokenSize);
  5711.                                                                      
  5712.                     myErr := AEDisposeDesc(newDesc);
  5713.                                                                      
  5714.                     IF (theWindowToken=NIL) THEN
  5715.                         myErr := errAEIllegalIndex
  5716.                     ELSE
  5717.                         BEGIN
  5718.                     
  5719.                             theDocument := DPtrFromWindowPtr(theWindowToken);
  5720.                             theHTE      := theDocument^.theText;
  5721.                             
  5722.                             IF (desiredType = cWord) THEN
  5723.                                 BEGIN
  5724.                                     wordStart   := 0;
  5725.                                     wordLength  := theHTE^^.teLength;
  5726.                                     result      := CountWords(theHTE, wordStart, wordLength);
  5727.                                 END;
  5728.                             
  5729.                             IF (desiredType = cChar) THEN
  5730.                                 result := theHTE^^.teLength;
  5731.                                 
  5732.                             IF (desiredType = cLine) THEN
  5733.                                 result := CountLines(theHTE);
  5734.                                 
  5735.                         END;
  5736.                 END;
  5737.                 
  5738.             myErr := AECoerceDesc(container, typeMyText, newDesc);
  5739.             IF (newDesc.descriptorType<>typeNull) THEN
  5740.                 BEGIN
  5741.                     GetRawDataFromDescriptor(    newDesc,
  5742.                                                                         @theTextToken,
  5743.                                                                         sizeOf(theTextToken),
  5744.                                                                         tokenSize);
  5745.                                                                      
  5746.                     myErr := AEDisposeDesc(newDesc);
  5747.                                                                      
  5748.                     theDocument := DPtrFromWindowPtr(theTextToken.tokenWindow);
  5749.                     theHTE      := theDocument^.theText;
  5750.                     
  5751.                     IF (desiredType = cWord) THEN
  5752.                         BEGIN
  5753.                             wordStart   := theTextToken.tokenOffset-1;
  5754.                             wordLength  := theTextToken.tokenLength;
  5755.                             result      := CountWords(theHTE, wordStart, wordLength);
  5756.                         END;
  5757.                     
  5758.                    IF (desiredType = cChar) THEN
  5759.                         result := theTextToken.tokenLength;
  5760.                         
  5761.                     IF (desiredType = cLine) THEN
  5762.                         result:= LineOfOffset(theHTE,theTextToken.tokenOffset-1) - 
  5763.                                  LineOfOffset(theHTE,theTextToken.tokenOffset+theTextToken.tokenLength-1)
  5764.                                          +1;                        
  5765.                 END;
  5766.                 
  5767.         END;
  5768.         
  5769.     MyCountProc := myErr;
  5770. END;    { MyCountProc }
  5771.  
  5772. {*****************************************************************************}
  5773. {
  5774.     Coercion Handlers - Allow AEResolve to do the hard work
  5775. }
  5776. FUNCTION CoerceObjToAnything(theAEDesc         : AEDesc;
  5777.                                                          toType            : DescType;
  5778.                                                      handlerRefCon: LongInt;
  5779.                                                          VAR result        :  AEDesc): OSErr;
  5780. {
  5781.     CoerceObjToAnything functions by using AEResolve to do the hard
  5782.     work.
  5783. }
  5784. CONST kAEIDoMinimum = 0;
  5785.  
  5786. VAR     myErr            : OSErr;
  5787.             objDesc        : AEDesc;
  5788.             
  5789. BEGIN
  5790.   myErr := errAECoercionFail;
  5791.     
  5792.     result.dataHandle := NIL;
  5793.     objDesc.dataHandle := NIL;
  5794.     
  5795.   
  5796.   IF (theAEDesc.descriptorType <> typeObjectSpecifier) THEN
  5797.     BEGIN
  5798.             CoerceObjToAnything := errAEWrongDataType;
  5799.             Exit(CoerceObjToAnything);
  5800.         END;
  5801.     
  5802.   { resolve the object specifier }
  5803.   myErr := AEResolve(theAEDesc,kAEIDoMinimum,objDesc);
  5804.       
  5805.   { hopefully it's the right type by now, but we'll give it a nudge }
  5806.   IF (myErr=noErr) THEN
  5807.         BEGIN
  5808.             myErr := AECoerceDesc(objDesc,toType,result);
  5809.            myErr := AEDisposeDesc(objDesc);
  5810.         END;
  5811.         
  5812.     IF (result.descriptorType<>toType) THEN
  5813.         BEGIN
  5814.             {DebugStr('COTA - Not of requested type');}
  5815.         END;
  5816.       
  5817.   CoerceObjToAnything := myErr;
  5818. END;    { CoerceObjToAnything }
  5819.  
  5820. {*****************************************************************************}
  5821.  
  5822. {----------------------------------------------------------------------------------------------}
  5823.  
  5824. {now for the edition manager event handling code}
  5825.  
  5826. FUNCTION GetHandleFromEvent(theAppleEvent : AppleEvent; VAR sectionH : SectionHandle):OSErr;
  5827.     
  5828.     VAR ignoreType : DescType;
  5829.             ignoreSize : Size;
  5830.     
  5831.     BEGIN
  5832.         GetHandleFromEvent := AEGetKeyPtr(theAppleEvent, keyDirectObject, typeSectionH, 
  5833.                                                                             ignoreType, @sectionH, SizeOf(sectionHandle), ignoreSize);
  5834.     END;
  5835.  
  5836. {----------------------------------------------------------------------------------------------}
  5837. FUNCTION DoReadSection(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  5838.     
  5839.     VAR err          : OSErr;
  5840.             sectionH : SectionHandle;
  5841.     
  5842.     BEGIN
  5843.         err := GetHandleFromEvent(theAppleEvent, sectionH);
  5844.         IF IsRegisteredSection(sectionH) = noErr THEN
  5845.             ReadAnEdition(sectionH);
  5846.         DoReadSection := err;
  5847.     END;
  5848.     
  5849. {----------------------------------------------------------------------------------------------}
  5850. FUNCTION DoWriteSection(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  5851.     
  5852.     VAR err          : OSErr;
  5853.             sectionH : SectionHandle;
  5854.     
  5855.     BEGIN
  5856.         err := GetHandleFromEvent(theAppleEvent, sectionH);
  5857.         IF IsRegisteredSection(sectionH) = noErr THEN
  5858.             WriteAnEdition(sectionH);
  5859.         DoWriteSection := err;
  5860.     
  5861.     END;
  5862.  
  5863. {----------------------------------------------------------------------------------------------}
  5864. FUNCTION DoScrollSection(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  5865.     
  5866.     VAR err                 : OSErr;
  5867.             sectionH        : SectionHandle;
  5868.             aSectHandle : SectHandle;
  5869.     
  5870.     BEGIN
  5871.         err := GetHandleFromEvent(theAppleEvent, sectionH);
  5872.         {get at the sectHandle}
  5873.         aSectHandle := SectHandle(GetERefCon(sectionH));
  5874.         TESetSelect(aSectHandle^^.fStart, aSectHandle^^.fEnd, aSectHandle^^.fDocument^.theText);
  5875.         ShowSelect(aSectHandle^^.fDocument);
  5876.         DoScrollSection := err;
  5877.     END;
  5878.  
  5879. {----------------------------------------------------------------------------------------------}
  5880. FUNCTION DoCancelSection(theAppleEvent, reply : AppleEvent; refCon : LONGINT): OSErr;
  5881.  
  5882.     VAR err                    : OSErr;
  5883.             sectionH        : SectionHandle;
  5884.             aSectHandle : SectHandle;
  5885.             
  5886.     BEGIN
  5887.         err := GetHandleFromEvent(theAppleEvent, sectionH);
  5888.         aSectHandle := SectHandle(GetERefCon(sectionH));
  5889.         err := UnRegisterSection(sectionH);
  5890.         DeleteASection(aSectHandle, aSectHandle^^.fDocument);
  5891.         DoCancelSection := noErr;
  5892.     END;
  5893.  
  5894. { -----------------------------------------------------------------------
  5895.         Name:             InitAppleEvents
  5896.         Purpose:        Initialise the AppleEvent despatch table
  5897.      -----------------------------------------------------------------------*}
  5898.  
  5899. {$S Main}
  5900. PROCEDURE InitAppleEvents;
  5901.  
  5902. CONST noRefCon = -1;
  5903. VAR
  5904.         aevtErr: OSErr ;
  5905. BEGIN
  5906.     gBigBrother := 0;
  5907.         gCharsInBuffer := 0;
  5908.         gTypingBuffer  := typingBufPtr(NewPtr(32000));
  5909.         gTypingTargetObject.dataHandle := NIL;
  5910.  
  5911.         
  5912.         {set up the despatch table for the four standard apple events}
  5913.         
  5914.         aevtErr := AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, @DoOpenApp, noRefCon, FALSE) ;
  5915.         aevtErr := AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments,   @DoOpenDocument, noRefCon, FALSE) ;
  5916.         aevtErr := AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments,  @DoPrintDocuments, noRefCon, FALSE) ;
  5917.         aevtErr := AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, @MyQuit, noRefCon, FALSE) ;
  5918.         
  5919.         { set up the despatch table for the core AppleEvents for text }
  5920.         
  5921.         aevtErr := AEInstallEventHandler( kAECoreSuite,     kAEDelete, @DoDeleteEdit,noRefCon, FALSE);
  5922.  
  5923.         aevtErr := AEInstallEventHandler( kAEMiscStandards, kAECut,    @DoCutEdit,   noRefCon, FALSE);
  5924.         aevtErr := AEInstallEventHandler( kAEMiscStandards, kAECopy,   @DoCopyEdit,  noRefCon, FALSE);
  5925.         aevtErr := AEInstallEventHandler( kAEMiscStandards, kAEPaste,  @DoPasteEdit, noRefCon, FALSE);
  5926.         aevtErr := AEInstallEventHandler( kAECoreSuite,     kAESetData,@DoSetData,   noRefCon, FALSE);
  5927.         aevtErr := AEInstallEventHandler( kAECoreSuite,     kAEGetData,@DoGetData,   noRefCon, FALSE);
  5928.         aevtErr := AEInstallEventHandler( kAECoreSuite,     kAEGetDataSize,@DoGetDataSize,   noRefCon, FALSE);
  5929.         
  5930.         aevtErr := AEInstallEventHandler( kAECoreSuite, kAECountElements,   @HandleNumberOfElements,   noRefCon, FALSE);
  5931.         aevtErr := AEInstallEventHandler( kAECoreSuite, kAECreateElement,   @DoNewElement,   noRefCon, FALSE);
  5932.         aevtErr := AEInstallEventHandler( kAECoreSuite, kAEDoObjectsExist,  @DoIsThereA,   noRefCon, FALSE);
  5933.     
  5934.         aevtErr := AEInstallEventHandler( kAECoreSuite,     kAEClose,  @DoCloseWindow,noRefCon, FALSE);
  5935.         aevtErr := AEInstallEventHandler( kAECoreSuite,     kAESave,   @DoSaveWindow,noRefCon, FALSE);
  5936.         aevtErr := AEInstallEventHandler( kAEMiscStandards, kAERevert, @DoRevertWindow,noRefCon, FALSE);
  5937.         
  5938.         aevtErr := AEInstallEventHandler( kAEMiscStandards, kAECreatePublisher,    @HandleCreatePub, noRefCon, FALSE);
  5939.         aevtErr := AEInstallEventHandler( kAEMiscStandards, kAEMakeObjectsVisible, @HandleShowSelection,   noRefCon, FALSE);
  5940.         
  5941.         { Now look for recording notifications }
  5942.         
  5943.         aevtErr := AEInstallEventHandler( kCoreEventClass, kAEStartedRecording, @HandleStartRecording, noRefCon, FALSE);
  5944.         aevtErr := AEInstallEventHandler( kCoreEventClass, kAEStoppedRecording, @HandleStopRecording, noRefCon, FALSE);
  5945.         
  5946.         { Now Put in the required object accessors }
  5947.         
  5948.         aevtErr := AESetObjectCallbacks(NIL,@MyCountProc,NIL,NIL,NIL,NIL,NIL);
  5949.         
  5950.         aevtErr := AEInstallObjectAccessor(cWindow,      typeNull,   @WindowFromNullAccessor,  0,FALSE);
  5951.         aevtErr := AEInstallObjectAccessor(cWindow,      typeMyAppl, @WindowFromNullAccessor,  0,FALSE);
  5952.         aevtErr := AEInstallObjectAccessor(cApplication, typeNull,   @ApplicationFromNullAccessor,  0,FALSE);
  5953.         aevtErr := AEInstallObjectAccessor(cProperty,    typeMyAppl, @PropertyFromApplAccessor,0,FALSE);
  5954.         
  5955.         aevtErr := AEInstallObjectAccessor(cChar,             typeMyWndw,@TextElemFromWndwAccessor,0,FALSE);
  5956.         aevtErr := AEInstallObjectAccessor(cSpot,             typeMyWndw,@TextElemFromWndwAccessor,0,FALSE);
  5957.         aevtErr := AEInstallObjectAccessor(cWord,             typeMyWndw,@TextElemFromWndwAccessor,0,FALSE);
  5958.         aevtErr := AEInstallObjectAccessor(cLine,             typeMyWndw,@TextElemFromWndwAccessor,0,FALSE);
  5959.         aevtErr := AEInstallObjectAccessor(cSelection, typeMyWndw,@TextElemFromWndwAccessor,0,FALSE);
  5960.         aevtErr := AEInstallObjectAccessor(cProperty,  typeMyWndw,@PropertyFromWndwAccessor,0,FALSE);
  5961.     
  5962.         aevtErr := AEInstallObjectAccessor(cProperty,     typeMyText,@PropertyFromTextAccessor,0,FALSE);
  5963.         aevtErr := AEInstallObjectAccessor(cChar,           typeMyText,@TextElemFromTextAccessor,0,FALSE);
  5964.         aevtErr := AEInstallObjectAccessor(cWord,           typeMyText,@TextElemFromTextAccessor,0,FALSE);
  5965.         aevtErr := AEInstallObjectAccessor(cLine,           typeMyText,@TextElemFromTextAccessor,0,FALSE);
  5966.         aevtErr := AEInstallObjectAccessor(cSpot,           typeMyText,@TextElemFromTextAccessor,0,FALSE);
  5967.         
  5968.         aevtErr := AEInstallObjectAccessor(cMenu,            typeNull,       @MenuFromNullAccessor,    0,false);
  5969.         aevtErr := AEInstallObjectAccessor(cProperty,   typeMyMenu,     @PropertyFromMenuAccessor,0,false);
  5970.         aevtErr := AEInstallObjectAccessor(cProperty,   typeMyMenuItem, @PropertyFromMenuItemAccessor,0,false);
  5971.         aevtErr := AEInstallObjectAccessor(cMenuItem,   typeMyMenu,     @MenuItemFromMenuAccessor,0,false);
  5972.         { Now the coercion handlers }
  5973.  
  5974.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyAppl,      @CoerceObjToAnything,0,TRUE,FALSE);
  5975.         aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyWndw,      @CoerceObjToAnything,0,TRUE,FALSE);
  5976.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyText,      @CoerceObjToAnything,0,TRUE,FALSE);
  5977.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyTextProp,  @CoerceObjToAnything,0,TRUE,FALSE);
  5978.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyWindowProp,@CoerceObjToAnything,0,TRUE,FALSE);
  5979.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyApplProp,  @CoerceObjToAnything,0,TRUE,FALSE);
  5980.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenu,      @CoerceObjToAnything,0,true,false);
  5981.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuProp,  @CoerceObjToAnything,0,true,false);
  5982.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuItem,  @CoerceObjToAnything,0,true,false);
  5983.       aevtErr := AEInstallCoercionHandler(typeObjectSpecifier,typeMyItemProp,  @CoerceObjToAnything,0,true,false);
  5984.         {now install the appropriate edition manager events}
  5985.         
  5986.         aevtErr := AEInstallEventHandler( sectionEventmsgClass, sectionReadMsgID, @DoReadSection, noRefCon, FALSE) ;
  5987.         aevtErr := AEInstallEventHandler( sectionEventmsgClass, sectionWriteMsgID, @DoWriteSection, noRefCon, FALSE) ;
  5988.         aevtErr := AEInstallEventHandler( sectionEventmsgClass, sectionScrollMsgID, @DoScrollSection, noRefCon, FALSE) ;
  5989.         aevtErr := AEInstallEventHandler( sectionEventmsgClass, sectionCancelMsgID, @DoCancelSection, noRefCon, FALSE) ;
  5990.         
  5991. END;
  5992.  
  5993.         
  5994. END.
  5995.